The private symbol property leads a conflict with the implemented interface.

[fenying]

TypeScript Version: v3.1.0-dev.20180804

Search Terms: private symbol property this generic parameter

Code

type F<T> = (this: T) => void;

interface IClassA {

    hello(): F<this>;
}

const p1 = Symbol("class:a:p1");

class A
implements IClassA {

    private [p1]: string;

    public hello(): F<this> {

        return function(): void {

            this[p1] = "123";

            delete this[p1];

            return;
        };
    }
}

// Here reports an error saying "Property '[p1]' is missing in type 'IClassA'"
let a: IClassA = new A();

Expected behavior:

I think it should work well without any error reporting.

Actual behavior:

It reports an error like this:

[ts]
Type 'A' is not assignable to type 'IClassA'.
  Types of property 'hello' are incompatible.
    Type '() => F<A>' is not assignable to type '() => F<IClassA>'.
      Type 'F<A>' is not assignable to type 'F<IClassA>'.
        The 'this' types of each signature are incompatible.
          Type 'IClassA' is not assignable to type 'A'.
            Property '[p1]' is missing in type 'IClassA'.

[p1 is a private property of the class, how could it lead a conflict with an implemented interface?

Playground Link:

Related Issues:

[RyanCavanaugh]

This is a correct error, oddly enough. Here's a simplified example that still shows the error:

type F<T> = (this: T) => void;
interface IClassA {
    hello(): F<this>;
}

class A implements IClassA {
    p1: string = '';
    public hello(): F<this> {
        return null as any;
    }
}

IClassA says that if you have an IClassA, it's legal to invoke hello with a this type of this (which is implicitly at least IClassA).

Again, oddly, A does not meet this constraint. A also says it's legal to invoke hello with a type of this (which is implicitly at least A). That last part is important. The code you have implies this code should be legal:

class A implements IClassA {
    p1: string = '';
    public hello(): F<this> {
        return () => {
            console.log(this.p1.toLowerCase());
        }
    }
}

let a: IClassA = new A();
let bad: IClassA = { hello: a.hello };
// Runtime error!
bad.hello();

The fix is to specify the type parameter of A's hello:

type F<T> = (this: T) => void;
interface IClassA {
    hello(): F<this>;
}

class A implements IClassA {
    p1: string = '';
    public hello<T extends IClassA>(this: T): F<T> {
        return () => {
            // Would be an error to write this now:
            // console.log(this.p1.toLowerCase());
        }
    }
}

let a: IClassA = new A();
let notbad: IClassA = { hello: a.hello };
// OK
notbad.hello();

[fenying]

@RyanCavanaugh

Emmmmm, thx for replying....

My question is:

1. Why it tells Property '[p1]' is missing in type 'IClassA'? It is a private property, how could it affect the interface implement checking?
2. Why there is no implement error in class definition? If the class A doesn't fit the interface IClassA.

And the error means this must be an instance of interface IClassA, but class A. If class A implements interface IClassA correctly, how could it produce such an error?

[RyanCavanaugh]

1. See the example code I posted - it doesn't matter if p1 is private
2. Classes with this references are secretly generic and TypeScript doesn't realize there's a problem until it's actually instantiated. Ideally it would be flagged at the declaration site but it's unfortunately not practical