78a99241d8
* Accept change * Accept the huge set of ever so slightly changed baselines * Update return type logic to only reuse nodes if original nodes share scope with current node, like property types, only reuse nodes if symbols referened are acessible, reuse nodes for property signatures, too * Only reuse nodes when a context is provided (otherwise identifier printback may fail) * Only track symbol if symbol is found and no error is recorded * Fix type parameter reuse lookup * Forbid cjs module.exports references in retained nodes * Adjust check for cjs export references to not include bad module type in output * Add symbol to all identifiers we see in existing nodes for quickinfo * Accept fourslash baseline updates * Accept slightly updated baseline post-merge * Do not copy original nodes for error types, replace empty type references with any
233 lines
7.1 KiB
Plaintext
233 lines
7.1 KiB
Plaintext
=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance3.ts ===
|
|
// checking subtype relations for function types as it relates to contextual signature instantiation
|
|
// error cases
|
|
|
|
module Errors {
|
|
>Errors : typeof Errors
|
|
|
|
class Base { foo: string; }
|
|
>Base : Base
|
|
>foo : string
|
|
|
|
class Derived extends Base { bar: string; }
|
|
>Derived : Derived
|
|
>Base : Base
|
|
>bar : string
|
|
|
|
class Derived2 extends Derived { baz: string; }
|
|
>Derived2 : Derived2
|
|
>Derived : Derived
|
|
>baz : string
|
|
|
|
class OtherDerived extends Base { bing: string; }
|
|
>OtherDerived : OtherDerived
|
|
>Base : Base
|
|
>bing : string
|
|
|
|
module WithNonGenericSignaturesInBaseType {
|
|
// base type with non-generic call signatures
|
|
interface A {
|
|
a2: new (x: number) => string[];
|
|
>a2 : new (x: number) => string[]
|
|
>x : number
|
|
|
|
a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived2;
|
|
>a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2
|
|
>x : (arg: Base) => Derived
|
|
>arg : Base
|
|
>r : Base
|
|
|
|
a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
|
|
>a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
|
|
>x : (arg: Base) => Derived
|
|
>arg : Base
|
|
>y : (arg2: Base) => Derived
|
|
>arg2 : Base
|
|
>r : Base
|
|
|
|
a10: new (...x: Base[]) => Base;
|
|
>a10 : new (...x: Base[]) => Base
|
|
>x : Base[]
|
|
|
|
a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
|
|
>a11 : new (x: { foo: string;}, y: { foo: string; bar: string;}) => Base
|
|
>x : { foo: string; }
|
|
>foo : string
|
|
>y : { foo: string; bar: string; }
|
|
>foo : string
|
|
>bar : string
|
|
|
|
a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
|
|
>a12 : new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
|
|
>x : Base[]
|
|
>y : Derived2[]
|
|
|
|
a14: {
|
|
>a14 : { new (x: number): number[]; new (x: string): string[]; }
|
|
|
|
new (x: number): number[];
|
|
>x : number
|
|
|
|
new (x: string): string[];
|
|
>x : string
|
|
|
|
};
|
|
a15: new (x: { a: string; b: number }) => number;
|
|
>a15 : new (x: { a: string; b: number;}) => number
|
|
>x : { a: string; b: number; }
|
|
>a : string
|
|
>b : number
|
|
|
|
a16: {
|
|
>a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; }
|
|
|
|
// type of parameter is overload set which means we can't do inference based on this type
|
|
new (x: {
|
|
>x : { new (a: number): number; new (a?: number): number; }
|
|
|
|
new (a: number): number;
|
|
>a : number
|
|
|
|
new (a?: number): number;
|
|
>a : number
|
|
|
|
}): number[];
|
|
new (x: {
|
|
>x : { new (a: boolean): boolean; new (a?: boolean): boolean; }
|
|
|
|
new (a: boolean): boolean;
|
|
>a : boolean
|
|
|
|
new (a?: boolean): boolean;
|
|
>a : boolean
|
|
|
|
}): boolean[];
|
|
};
|
|
}
|
|
|
|
interface I extends A {
|
|
a2: new <T, U>(x: T) => U[]; // error, contextual signature instantiation doesn't relate return types so U is {}, not a subtype of string[]
|
|
>a2 : new <T, U>(x: T) => U[]
|
|
>x : T
|
|
}
|
|
|
|
interface I2<T, U> extends A {
|
|
a2: new (x: T) => U[]; // error, no contextual signature instantiation since I2.a2 is not generic
|
|
>a2 : new (x: T) => U[]
|
|
>x : T
|
|
}
|
|
|
|
interface I3 extends A {
|
|
// valid, no inferences for V so it defaults to Derived2
|
|
a7: new <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V;
|
|
>a7 : new <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
|
|
>x : (arg: T) => U
|
|
>arg : T
|
|
>r : T
|
|
}
|
|
|
|
interface I4 extends A {
|
|
a8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; // error, type mismatch
|
|
>a8 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number;}) => U) => (r: T) => U
|
|
>x : (arg: T) => U
|
|
>arg : T
|
|
>y : (arg2: { foo: number;}) => U
|
|
>arg2 : { foo: number; }
|
|
>foo : number
|
|
>r : T
|
|
}
|
|
|
|
interface I4B extends A {
|
|
a10: new <T extends Derived>(...x: T[]) => T; // valid, parameter covariance works even after contextual signature instantiation
|
|
>a10 : new <T extends Derived>(...x: T[]) => T
|
|
>x : T[]
|
|
}
|
|
|
|
interface I4C extends A {
|
|
a11: new <T extends Derived>(x: T, y: T) => T; // valid, even though x is a Base, parameter covariance works even after contextual signature instantiation
|
|
>a11 : new <T extends Derived>(x: T, y: T) => T
|
|
>x : T
|
|
>y : T
|
|
}
|
|
|
|
interface I4E extends A {
|
|
a12: new <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T; // valid, no inferences for T, defaults to Array<Derived2>
|
|
>a12 : new <T extends Derived2[]>(x: Array<Base>, y: Array<Base>) => T
|
|
>x : Base[]
|
|
>y : Base[]
|
|
}
|
|
|
|
interface I6 extends A {
|
|
a15: new <T>(x: { a: T; b: T }) => T; // error, T is {} which isn't an acceptable return type
|
|
>a15 : new <T>(x: { a: T; b: T; }) => T
|
|
>x : { a: T; b: T; }
|
|
>a : T
|
|
>b : T
|
|
}
|
|
|
|
interface I7 extends A {
|
|
a15: new <T extends Base>(x: { a: T; b: T }) => number; // error, T defaults to Base, which is not compatible with number or string
|
|
>a15 : new <T extends Base>(x: { a: T; b: T; }) => number
|
|
>x : { a: T; b: T; }
|
|
>a : T
|
|
>b : T
|
|
}
|
|
|
|
interface I8 extends A {
|
|
// ok, we relate each signature of a16 to b16, and within that, we make inferences from two different signatures in the respective A.a16 signature
|
|
a16: new <T>(x: new (a: T) => T) => T[];
|
|
>a16 : new <T>(x: new (a: T) => T) => T[]
|
|
>x : new (a: T) => T
|
|
>a : T
|
|
}
|
|
}
|
|
|
|
module WithGenericSignaturesInBaseType {
|
|
// base type has generic call signature
|
|
interface B {
|
|
a2: new <T>(x: T) => T[];
|
|
>a2 : new <T>(x: T) => T[]
|
|
>x : T
|
|
}
|
|
|
|
interface I6 extends B {
|
|
a2: new <T>(x: T) => string[]; // error
|
|
>a2 : new <T>(x: T) => string[]
|
|
>x : T
|
|
}
|
|
|
|
// base type has generic call signature
|
|
interface C {
|
|
a2: new <T>(x: T) => string[];
|
|
>a2 : new <T>(x: T) => string[]
|
|
>x : T
|
|
}
|
|
|
|
interface I7 extends C {
|
|
a2: new <T>(x: T) => T[]; // error
|
|
>a2 : new <T>(x: T) => T[]
|
|
>x : T
|
|
}
|
|
|
|
// base type has a generic call signature with overloads
|
|
interface D {
|
|
a14: {
|
|
>a14 : { new <T extends Derived>(x: T): number[]; new <U extends Base>(x: U): number[]; }
|
|
|
|
new <T extends Derived>(x: T): number[];
|
|
>x : T
|
|
|
|
new <U extends Base>(x: U): number[];
|
|
>x : U
|
|
|
|
};
|
|
}
|
|
|
|
interface I8 extends D {
|
|
a14: new <T extends Base>(x: T) => number[];
|
|
>a14 : new <T extends Base>(x: T) => number[]
|
|
>x : T
|
|
}
|
|
}
|
|
}
|