Comparison targets are reversed (regression)

[falsandtru]

@RyanCavanaugh @weswigham @ahejlsberg Caused by #27697

TypeScript Version: 3.4.0-dev.20190222

Search Terms:

Code

https://github.com/falsandtru/spica/blob/v0.0.237/src/supervisor.legacy.ts#L49

Expected behavior:

pass

Actual behavior:

Argument of type 'this' is not assignable to parameter of type 'Supervisor<string, unknown, unknown, unknown>'.
  Type 'Supervisor<N, P, R, S>' is not assignable to type 'Supervisor<string, unknown, unknown, unknown>'.
    Type 'string' is not assignable to type 'N'.ts(2345)

Assignability checking must be N to string, not reverse.

Playground Link:

Related Issues:

[RyanCavanaugh]

@falsandtru please provide a reduced repro - thanks!

[jack-williams]

@falsandtru Is this a repro?

interface Foo<T> {
    cast(name: ('' extends T ? string : string)): void;
}

interface Foo2<T> {
    cast(name: ('' extends T ? string : string)): void;
}

declare const y: Foo<string>;
const x: Foo<''> = y; // error

declare const y2: Foo2<string>;
const x2: Foo<''> = y2; // ok

[falsandtru]

@RyanCavanaugh Repro

export abstract class Supervisor<N extends string, P = unknown, R = unknown> {
  private static instances_: Set<Supervisor<string, unknown, unknown>>;
  private static get instances(): typeof Supervisor.instances_ {
    return this.hasOwnProperty('instances_')
      ? this.instances_
      : this.instances_ = new Set();
  }
  constructor() {
    void (this.constructor as typeof Supervisor).instances.add(this);
  }
  public abstract call(name: N | ('' extends N ? undefined : never), param: P, timeout?: number): Promise<R>;
}

@jack-williams No. The type parameters in your repro are not reversed.

[jack-williams]

@falsandtru Yep, sorry. What about this?

class Foo<T extends string> {
    private static instance: Foo<string>[];

    cast(_name: ([T] extends [string] ? string : string)) {
        
    }
    
    foobar() {
        Foo.instance.push(this);
    }
}

[falsandtru]

Looks like good except an illegal ! at the second line.