"Two different types with this name exist, but they are unrelated" emitted when same

[shanehsu]

TypeScript Version: Version 3.1.0-dev.20180823

Search Terms: Different types with same name

Code

export type Constructor<T> = new (...args: any[]) => T
export type MappedResult<T> =
    T extends Boolean ? boolean :
    T extends Number ? number :
    T extends String ? string :
    T


interface X {
    decode<C extends Constructor<any>>(ctor: C): MappedResult<C extends Constructor<infer T> ? T : never>
}

class Y implements X {
    decode<C extends Constructor<any>>(ctor: C): MappedResult<C extends Constructor<infer T> ? T : never> {
        throw new Error()
    }
}

Expected behavior: It should compile without any error. Everything is in the same namespace, so it should be the same type.

Actual behavior: The quoted error below is emitted.

$ tsc tsc-test.ts
tsc-test.ts:14:5 - error TS2416: Property 'decode' in type 'Y' is not assignable to the same property in base type 'X'.
  Type '<C extends import("tsc-test").Constructor<any>>(ctor: C) => import("tsc-test").MappedResult<C extends import("tsc-test").Constructor<infer T> ? T : never>' is not assignable to type '<C extends import("tsc-test").Constructor<any>>(ctor: C) => import("tsc-test").MappedResult<C extends import("tsc-test").Constructor<infer T> ? T : never>'. Two different types with this name exist, but they are unrelated.
    Type 'import("tsc-test").MappedResult<C extends import("tsc-test").Constructor<infer T> ? T : never>' is not assignable to type 'import("tsc-test").MappedResult<C extends import("tsc-test").Constructor<infer T> ? T : never>'. Two different types with this name exist, but they are unrelated.

14     decode<C extends Constructor<any>>(ctor: C): MappedResult<C extends Constructor<infer T> ? T : never> {
       ~~~~~~

Playground Link: Here

Related Issues: None I can find

[jcalz]

related to #25373 ?

I think this is a different issue having to do with conditoinal types.

interface I {
    m<T>(): T extends Array<infer U> ? U : never
}

class C implements I {
    m<T>(): T extends Array<infer U> ? U : never { // Error?
        throw new Error();
    }
}

Also, the following should be an error but isn't:

interface I {
    m<T>(): T extends Array<infer U> ? U : never
}

class C implements I {
    m<T>(): T {
        throw new Error();
    }
}

[ahejlsberg]

The issue here is that conditional types with inference positions (i.e. infer X declarations in their extends types) introduce distinct type identities for the inferred type variables. When relating conditional types we currently aren't unifying inference type variables, so distinct conditional types with inference positions will always appear unrelated.

The simple workaround is to declare a type alias and use this type alias in both places:

type CtorParams<T> = C extends Constructor<infer T> ? T : never;

interface X {
    decode<C extends Constructor<any>>(ctor: C): MappedResult<CtorParams<T>>
}

class Y implements X {
    decode<C extends Constructor<any>>(ctor: C): MappedResult<CtorParams<T>> {
        throw new Error()
    }
}

This causes the checker to realize the types are the same.

[ahejlsberg]

@Andy-MS The second issue isn't really meaningful because T is never used in a parameter position. It's basically just another way of writing a type assertion.

Consider this instead:

interface A {
    m<T>(x: T[]): T[];
}

interface B extends A {
    m<U>(x: U): U;
}

The above example is fine because when we instantiate B.m in the context of A.m we infer T[] for U. But we report an error on this:

interface A {
    m<T>(x: T): T[];
}

interface B extends A {
    m<U>(x: U): U;
}

This error is caused by inferring both T and T[] for U which isn't consistent.

[legion-gaming]

The same sort of issue still exists from #16786. Consider the following (this works in C# if you look at the Enumerable.cs class: https://github.com/Microsoft/referencesource/blob/4.6.2/System.Core/System/Linq/Enumerable.cs)

export interface IOrderedEnumerable<T> extends IEnumerable<T> {
	thenBy<TKey>(selector: (in1: T) => TKey, comparer?: IComparer<TKey>): IOrderedEnumerable<T>;
	thenByDescending<TKey>(selector: (in1: T) => TKey, comparer?: IComparer<TKey>): IOrderedEnumerable<T>;
}

export class OrderedEnumerable<T, TKey> extends Enumerable<T> implements IOrderedEnumerable<T> {
        // other code here omitted

	thenBy(selector: (in1: T) => TKey, comparer?: IComparer<TKey>): IOrderedEnumerable<T> {
		throw new Error("Not implemented");
	}

	thenByDescending(selector: (in1: T) => TKey, comparer?: IComparer<TKey>): IOrderedEnumerable<T> {
		throw new Error("Not implemented");
	}
}

As you see in the concrete class above, the TKey generic should be inferred from the class for those thenBy functions, but the compiler fails with the "Two different types with this name exist, but they are unrelated" error.