microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-04 21:53:42 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge pull request #919 from Microsoft/optionalPropertySubtyping

Browse Source 
Require optional properties to be present in subtypes
This commit is contained in:
Anders Hejlsberg 2014-10-20 11:47:22 -07:00
commit a537cb3f02
16 changed files with 1666 additions and 935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/compiler/checker.ts
View File

@ -3372,7 +3372,7 @@ module ts {
var sourceProp = getPropertyOfApparentType(<ApparentType>source, targetProp.name);
if (sourceProp !== targetProp) {
if (!sourceProp) {
if (!isOptionalProperty(targetProp)) {
if (relation === subtypeRelation || !isOptionalProperty(targetProp)) {
if (reportErrors) {
reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source));
}
@ -3661,10 +3661,6 @@ module ts {
return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
}
function getBestCommonType(types: Type[], contextualType: Type): Type {
return contextualType && isSupertypeOfEach(contextualType, types) ? contextualType : getUnionType(types);
}
function isTypeOfObjectLiteral(type: Type): boolean {
return (type.flags & TypeFlags.Anonymous) && type.symbol && (type.symbol.flags & SymbolFlags.ObjectLiteral) ? true : false;
}
@ -5751,7 +5747,7 @@ module ts {
case SyntaxKind.GreaterThanToken:
case SyntaxKind.LessThanEqualsToken:
case SyntaxKind.GreaterThanEqualsToken:
if (!isTypeSubtypeOf(leftType, rightType) && !isTypeSubtypeOf(rightType, leftType)) {
if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) {
reportOperatorError();
}
return booleanType;

4
src/compiler/emitter.ts
View File

@ -2868,7 +2868,7 @@ module ts {
}
return {
diagnosticMessage: diagnosticMessage,
errorNode: node.parameters[0],
errorNode: <Node>node.parameters[0],
typeName: node.name
};
}
@ -2889,7 +2889,7 @@ module ts {
}
return {
diagnosticMessage: diagnosticMessage,
errorNode: node.name,
errorNode: <Node>node.name,
typeName: undefined
};
}

20
tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
View File

@ -17,20 +17,20 @@ var c: { x: number; a?: number };
>a : number
var as = [a, b]; // { x: number; y?: number };[]
>as : { x: number; y?: number; }[]
>[a, b] : { x: number; y?: number; }[]
>as : ({ x: number; y?: number; } | { x: number; z?: number; })[]
>[a, b] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }
var bs = [b, a]; // { x: number; z?: number };[]
>bs : { x: number; y?: number; }[]
>[b, a] : { x: number; y?: number; }[]
>bs : ({ x: number; y?: number; } | { x: number; z?: number; })[]
>[b, a] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
>b : { x: number; z?: number; }
>a : { x: number; y?: number; }
var cs = [a, b, c]; // { x: number; y?: number };[]
>cs : { x: number; y?: number; }[]
>[a, b, c] : { x: number; y?: number; }[]
>cs : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
>[a, b, c] : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }
>c : { x: number; a?: number; }
@ -54,8 +54,8 @@ var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
>Object : Object
var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
>fs : ((a: { x: number; y?: number; }) => number)[]
>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : ((a: { x: number; y?: number; }) => number)[]
>fs : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
>(a: { x: number; y?: number }) => 1 : (a: { x: number; y?: number; }) => number
>a : { x: number; y?: number; }
>x : number
@ -66,8 +66,8 @@ var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) =>
>z : number
var gs = [(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1]; // (b: { x: number; z?: number }) => number[]
>gs : ((b: { x: number; z?: number; }) => number)[]
>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : ((b: { x: number; z?: number; }) => number)[]
>gs : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
>(b: { x: number; z?: number }) => 2 : (b: { x: number; z?: number; }) => number
>b : { x: number; z?: number; }
>x : number

8
tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
View File

@ -48,14 +48,14 @@ var r3 = true ? 1 : {};
>{} : {}
var r4 = true ? a : b; // typeof a
>r4 : { x: number; y?: number; }
>true ? a : b : { x: number; y?: number; }
>r4 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? a : b : { x: number; y?: number; } | { x: number; z?: number; }
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }
var r5 = true ? b : a; // typeof b
>r5 : { x: number; y?: number; }
>true ? b : a : { x: number; y?: number; }
>r5 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
>b : { x: number; z?: number; }
>a : { x: number; y?: number; }

215
tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt
View File

@ -1,215 +0,0 @@
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(40,12): error TS2365: Operator '<' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(57,12): error TS2365: Operator '>' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(74,12): error TS2365: Operator '<=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(91,12): error TS2365: Operator '>=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(108,12): error TS2365: Operator '==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(125,12): error TS2365: Operator '!=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(142,12): error TS2365: Operator '===' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(159,12): error TS2365: Operator '!==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts (16 errors) ====
class Base {
public a: string;
}
class Derived extends Base {
public b: string;
}
var a1: { fn<T>(x: T): T };
var b1: { fn(x: string): string };
var a2: { fn<T>(x: T): T };
var b2: { fn(x: string, y: number): string };
var a3: { fn<T, U>(x: T, y: U): T };
var b3: { fn(x: string, y: number): string };
var a4: { fn<T>(x?: T): T };
var b4: { fn(x?: string): string };
var a5: { fn<T>(...x: T[]): T };
var b5: { fn(...x: string[]): string };
var a6: { fn<T>(x: T, y: T): T };
var b6: { fn(x: string, y: number): {} };
//var a7: { fn<T, U extends T>(x: T, y: U): T };
var b7: { fn(x: Base, y: Derived): Base };
// operator <
var r1a1 = a1 < b1;
var r1a2 = a2 < b2;
~~~~~~~
!!! error TS2365: Operator '<' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r1a3 = a3 < b3;
var r1a4 = a4 < b4;
var r1a5 = a5 < b5;
var r1a6 = a6 < b6;
//var r1a7 = a7 < b7;
var r1b1 = b1 < a1;
var r1b2 = b2 < a2;
~~~~~~~
!!! error TS2365: Operator '<' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r1b3 = b3 < a3;
var r1b4 = b4 < a4;
var r1b5 = b5 < a5;
var r1b6 = b6 < a6;
//var r1b7 = b7 < a7;
// operator >
var r2a1 = a1 > b1;
var r2a2 = a2 > b2;
~~~~~~~
!!! error TS2365: Operator '>' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r2a3 = a3 > b3;
var r2a4 = a4 > b4;
var r2a5 = a5 > b5;
var r2a6 = a6 > b6;
//var r2a7 = a7 > b7;
var r2b1 = b1 > a1;
var r2b2 = b2 > a2;
~~~~~~~
!!! error TS2365: Operator '>' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r2b3 = b3 > a3;
var r2b4 = b4 > a4;
var r2b5 = b5 > a5;
var r2b6 = b6 > a6;
//var r2b7 = b7 > a7;
// operator <=
var r3a1 = a1 <= b1;
var r3a2 = a2 <= b2;
~~~~~~~~
!!! error TS2365: Operator '<=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r3a3 = a3 <= b3;
var r3a4 = a4 <= b4;
var r3a5 = a5 <= b5;
var r3a6 = a6 <= b6;
//var r3a7 = a7 <= b7;
var r3b1 = b1 <= a1;
var r3b2 = b2 <= a2;
~~~~~~~~
!!! error TS2365: Operator '<=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r3b3 = b3 <= a3;
var r3b4 = b4 <= a4;
var r3b5 = b5 <= a5;
var r3b6 = b6 <= a6;
//var r3b7 = b7 <= a7;
// operator >=
var r4a1 = a1 >= b1;
var r4a2 = a2 >= b2;
~~~~~~~~
!!! error TS2365: Operator '>=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r4a3 = a3 >= b3;
var r4a4 = a4 >= b4;
var r4a5 = a5 >= b5;
var r4a6 = a6 >= b6;
//var r4a7 = a7 >= b7;
var r4b1 = b1 >= a1;
var r4b2 = b2 >= a2;
~~~~~~~~
!!! error TS2365: Operator '>=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r4b3 = b3 >= a3;
var r4b4 = b4 >= a4;
var r4b5 = b5 >= a5;
var r4b6 = b6 >= a6;
//var r4b7 = b7 >= a7;
// operator ==
var r5a1 = a1 == b1;
var r5a2 = a2 == b2;
~~~~~~~~
!!! error TS2365: Operator '==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r5a3 = a3 == b3;
var r5a4 = a4 == b4;
var r5a5 = a5 == b5;
var r5a6 = a6 == b6;
//var r5a7 = a7 == b7;
var r5b1 = b1 == a1;
var r5b2 = b2 == a2;
~~~~~~~~
!!! error TS2365: Operator '==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r5b3 = b3 == a3;
var r5b4 = b4 == a4;
var r5b5 = b5 == a5;
var r5b6 = b6 == a6;
//var r5b7 = b7 == a7;
// operator !=
var r6a1 = a1 != b1;
var r6a2 = a2 != b2;
~~~~~~~~
!!! error TS2365: Operator '!=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r6a3 = a3 != b3;
var r6a4 = a4 != b4;
var r6a5 = a5 != b5;
var r6a6 = a6 != b6;
//var r6a7 = a7 != b7;
var r6b1 = b1 != a1;
var r6b2 = b2 != a2;
~~~~~~~~
!!! error TS2365: Operator '!=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r6b3 = b3 != a3;
var r6b4 = b4 != a4;
var r6b5 = b5 != a5;
var r6b6 = b6 != a6;
//var r6b7 = b7 != a7;
// operator ===
var r7a1 = a1 === b1;
var r7a2 = a2 === b2;
~~~~~~~~~
!!! error TS2365: Operator '===' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r7a3 = a3 === b3;
var r7a4 = a4 === b4;
var r7a5 = a5 === b5;
var r7a6 = a6 === b6;
//var r7a7 = a7 === b7;
var r7b1 = b1 === a1;
var r7b2 = b2 === a2;
~~~~~~~~~
!!! error TS2365: Operator '===' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r7b3 = b3 === a3;
var r7b4 = b4 === a4;
var r7b5 = b5 === a5;
var r7b6 = b6 === a6;
//var r7b7 = b7 === a7;
// operator !==
var r8a1 = a1 !== b1;
var r8a2 = a2 !== b2;
~~~~~~~~~
!!! error TS2365: Operator '!==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
var r8a3 = a3 !== b3;
var r8a4 = a4 !== b4;
var r8a5 = a5 !== b5;
var r8a6 = a6 !== b6;
//var r8a7 = a7 !== b7;
var r8b1 = b1 !== a1;
var r8b2 = b2 !== a2;
~~~~~~~~~
!!! error TS2365: Operator '!==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
var r8b3 = b3 !== a3;
var r8b4 = b4 !== a4;
var r8b5 = b5 !== a5;
var r8b6 = b6 !== a6;
//var r8b7 = b7 !== a7;

727
tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types Normal file
View File

@ -0,0 +1,727 @@
=== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts ===
class Base {
>Base : Base
public a: string;
>a : string
}
class Derived extends Base {
>Derived : Derived
>Base : Base
public b: string;
>b : string
}
var a1: { fn<T>(x: T): T };
>a1 : { fn<T>(x: T): T; }
>fn : <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
var b1: { fn(x: string): string };
>b1 : { fn(x: string): string; }
>fn : (x: string) => string
>x : string
var a2: { fn<T>(x: T): T };
>a2 : { fn<T>(x: T): T; }
>fn : <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
var b2: { fn(x: string, y: number): string };
>b2 : { fn(x: string, y: number): string; }
>fn : (x: string, y: number) => string
>x : string
>y : number
var a3: { fn<T, U>(x: T, y: U): T };
>a3 : { fn<T, U>(x: T, y: U): T; }
>fn : <T, U>(x: T, y: U) => T
>T : T
>U : U
>x : T
>T : T
>y : U
>U : U
>T : T
var b3: { fn(x: string, y: number): string };
>b3 : { fn(x: string, y: number): string; }
>fn : (x: string, y: number) => string
>x : string
>y : number
var a4: { fn<T>(x?: T): T };
>a4 : { fn<T>(x?: T): T; }
>fn : <T>(x?: T) => T
>T : T
>x : T
>T : T
>T : T
var b4: { fn(x?: string): string };
>b4 : { fn(x?: string): string; }
>fn : (x?: string) => string
>x : string
var a5: { fn<T>(...x: T[]): T };
>a5 : { fn<T>(...x: T[]): T; }
>fn : <T>(...x: T[]) => T
>T : T
>x : T[]
>T : T
>T : T
var b5: { fn(...x: string[]): string };
>b5 : { fn(...x: string[]): string; }
>fn : (...x: string[]) => string
>x : string[]
var a6: { fn<T>(x: T, y: T): T };
>a6 : { fn<T>(x: T, y: T): T; }
>fn : <T>(x: T, y: T) => T
>T : T
>x : T
>T : T
>y : T
>T : T
>T : T
var b6: { fn(x: string, y: number): {} };
>b6 : { fn(x: string, y: number): {}; }
>fn : (x: string, y: number) => {}
>x : string
>y : number
//var a7: { fn<T, U extends T>(x: T, y: U): T };
var b7: { fn(x: Base, y: Derived): Base };
>b7 : { fn(x: Base, y: Derived): Base; }
>fn : (x: Base, y: Derived) => Base
>x : Base
>Base : Base
>y : Derived
>Derived : Derived
>Base : Base
// operator <
var r1a1 = a1 < b1;
>r1a1 : boolean
>a1 < b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r1a2 = a2 < b2;
>r1a2 : boolean
>a2 < b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r1a3 = a3 < b3;
>r1a3 : boolean
>a3 < b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r1a4 = a4 < b4;
>r1a4 : boolean
>a4 < b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r1a5 = a5 < b5;
>r1a5 : boolean
>a5 < b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r1a6 = a6 < b6;
>r1a6 : boolean
>a6 < b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r1a7 = a7 < b7;
var r1b1 = b1 < a1;
>r1b1 : boolean
>b1 < a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r1b2 = b2 < a2;
>r1b2 : boolean
>b2 < a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r1b3 = b3 < a3;
>r1b3 : boolean
>b3 < a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r1b4 = b4 < a4;
>r1b4 : boolean
>b4 < a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r1b5 = b5 < a5;
>r1b5 : boolean
>b5 < a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r1b6 = b6 < a6;
>r1b6 : boolean
>b6 < a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r1b7 = b7 < a7;
// operator >
var r2a1 = a1 > b1;
>r2a1 : boolean
>a1 > b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r2a2 = a2 > b2;
>r2a2 : boolean
>a2 > b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r2a3 = a3 > b3;
>r2a3 : boolean
>a3 > b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r2a4 = a4 > b4;
>r2a4 : boolean
>a4 > b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r2a5 = a5 > b5;
>r2a5 : boolean
>a5 > b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r2a6 = a6 > b6;
>r2a6 : boolean
>a6 > b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r2a7 = a7 > b7;
var r2b1 = b1 > a1;
>r2b1 : boolean
>b1 > a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r2b2 = b2 > a2;
>r2b2 : boolean
>b2 > a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r2b3 = b3 > a3;
>r2b3 : boolean
>b3 > a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r2b4 = b4 > a4;
>r2b4 : boolean
>b4 > a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r2b5 = b5 > a5;
>r2b5 : boolean
>b5 > a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r2b6 = b6 > a6;
>r2b6 : boolean
>b6 > a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r2b7 = b7 > a7;
// operator <=
var r3a1 = a1 <= b1;
>r3a1 : boolean
>a1 <= b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r3a2 = a2 <= b2;
>r3a2 : boolean
>a2 <= b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r3a3 = a3 <= b3;
>r3a3 : boolean
>a3 <= b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r3a4 = a4 <= b4;
>r3a4 : boolean
>a4 <= b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r3a5 = a5 <= b5;
>r3a5 : boolean
>a5 <= b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r3a6 = a6 <= b6;
>r3a6 : boolean
>a6 <= b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r3a7 = a7 <= b7;
var r3b1 = b1 <= a1;
>r3b1 : boolean
>b1 <= a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r3b2 = b2 <= a2;
>r3b2 : boolean
>b2 <= a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r3b3 = b3 <= a3;
>r3b3 : boolean
>b3 <= a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r3b4 = b4 <= a4;
>r3b4 : boolean
>b4 <= a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r3b5 = b5 <= a5;
>r3b5 : boolean
>b5 <= a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r3b6 = b6 <= a6;
>r3b6 : boolean
>b6 <= a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r3b7 = b7 <= a7;
// operator >=
var r4a1 = a1 >= b1;
>r4a1 : boolean
>a1 >= b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r4a2 = a2 >= b2;
>r4a2 : boolean
>a2 >= b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r4a3 = a3 >= b3;
>r4a3 : boolean
>a3 >= b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r4a4 = a4 >= b4;
>r4a4 : boolean
>a4 >= b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r4a5 = a5 >= b5;
>r4a5 : boolean
>a5 >= b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r4a6 = a6 >= b6;
>r4a6 : boolean
>a6 >= b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r4a7 = a7 >= b7;
var r4b1 = b1 >= a1;
>r4b1 : boolean
>b1 >= a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r4b2 = b2 >= a2;
>r4b2 : boolean
>b2 >= a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r4b3 = b3 >= a3;
>r4b3 : boolean
>b3 >= a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r4b4 = b4 >= a4;
>r4b4 : boolean
>b4 >= a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r4b5 = b5 >= a5;
>r4b5 : boolean
>b5 >= a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r4b6 = b6 >= a6;
>r4b6 : boolean
>b6 >= a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r4b7 = b7 >= a7;
// operator ==
var r5a1 = a1 == b1;
>r5a1 : boolean
>a1 == b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r5a2 = a2 == b2;
>r5a2 : boolean
>a2 == b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r5a3 = a3 == b3;
>r5a3 : boolean
>a3 == b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r5a4 = a4 == b4;
>r5a4 : boolean
>a4 == b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r5a5 = a5 == b5;
>r5a5 : boolean
>a5 == b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r5a6 = a6 == b6;
>r5a6 : boolean
>a6 == b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r5a7 = a7 == b7;
var r5b1 = b1 == a1;
>r5b1 : boolean
>b1 == a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r5b2 = b2 == a2;
>r5b2 : boolean
>b2 == a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r5b3 = b3 == a3;
>r5b3 : boolean
>b3 == a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r5b4 = b4 == a4;
>r5b4 : boolean
>b4 == a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r5b5 = b5 == a5;
>r5b5 : boolean
>b5 == a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r5b6 = b6 == a6;
>r5b6 : boolean
>b6 == a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r5b7 = b7 == a7;
// operator !=
var r6a1 = a1 != b1;
>r6a1 : boolean
>a1 != b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r6a2 = a2 != b2;
>r6a2 : boolean
>a2 != b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r6a3 = a3 != b3;
>r6a3 : boolean
>a3 != b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r6a4 = a4 != b4;
>r6a4 : boolean
>a4 != b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r6a5 = a5 != b5;
>r6a5 : boolean
>a5 != b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r6a6 = a6 != b6;
>r6a6 : boolean
>a6 != b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r6a7 = a7 != b7;
var r6b1 = b1 != a1;
>r6b1 : boolean
>b1 != a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r6b2 = b2 != a2;
>r6b2 : boolean
>b2 != a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r6b3 = b3 != a3;
>r6b3 : boolean
>b3 != a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r6b4 = b4 != a4;
>r6b4 : boolean
>b4 != a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r6b5 = b5 != a5;
>r6b5 : boolean
>b5 != a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r6b6 = b6 != a6;
>r6b6 : boolean
>b6 != a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r6b7 = b7 != a7;
// operator ===
var r7a1 = a1 === b1;
>r7a1 : boolean
>a1 === b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r7a2 = a2 === b2;
>r7a2 : boolean
>a2 === b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r7a3 = a3 === b3;
>r7a3 : boolean
>a3 === b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r7a4 = a4 === b4;
>r7a4 : boolean
>a4 === b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r7a5 = a5 === b5;
>r7a5 : boolean
>a5 === b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r7a6 = a6 === b6;
>r7a6 : boolean
>a6 === b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r7a7 = a7 === b7;
var r7b1 = b1 === a1;
>r7b1 : boolean
>b1 === a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r7b2 = b2 === a2;
>r7b2 : boolean
>b2 === a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r7b3 = b3 === a3;
>r7b3 : boolean
>b3 === a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r7b4 = b4 === a4;
>r7b4 : boolean
>b4 === a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r7b5 = b5 === a5;
>r7b5 : boolean
>b5 === a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r7b6 = b6 === a6;
>r7b6 : boolean
>b6 === a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r7b7 = b7 === a7;
// operator !==
var r8a1 = a1 !== b1;
>r8a1 : boolean
>a1 !== b1 : boolean
>a1 : { fn<T>(x: T): T; }
>b1 : { fn(x: string): string; }
var r8a2 = a2 !== b2;
>r8a2 : boolean
>a2 !== b2 : boolean
>a2 : { fn<T>(x: T): T; }
>b2 : { fn(x: string, y: number): string; }
var r8a3 = a3 !== b3;
>r8a3 : boolean
>a3 !== b3 : boolean
>a3 : { fn<T, U>(x: T, y: U): T; }
>b3 : { fn(x: string, y: number): string; }
var r8a4 = a4 !== b4;
>r8a4 : boolean
>a4 !== b4 : boolean
>a4 : { fn<T>(x?: T): T; }
>b4 : { fn(x?: string): string; }
var r8a5 = a5 !== b5;
>r8a5 : boolean
>a5 !== b5 : boolean
>a5 : { fn<T>(...x: T[]): T; }
>b5 : { fn(...x: string[]): string; }
var r8a6 = a6 !== b6;
>r8a6 : boolean
>a6 !== b6 : boolean
>a6 : { fn<T>(x: T, y: T): T; }
>b6 : { fn(x: string, y: number): {}; }
//var r8a7 = a7 !== b7;
var r8b1 = b1 !== a1;
>r8b1 : boolean
>b1 !== a1 : boolean
>b1 : { fn(x: string): string; }
>a1 : { fn<T>(x: T): T; }
var r8b2 = b2 !== a2;
>r8b2 : boolean
>b2 !== a2 : boolean
>b2 : { fn(x: string, y: number): string; }
>a2 : { fn<T>(x: T): T; }
var r8b3 = b3 !== a3;
>r8b3 : boolean
>b3 !== a3 : boolean
>b3 : { fn(x: string, y: number): string; }
>a3 : { fn<T, U>(x: T, y: U): T; }
var r8b4 = b4 !== a4;
>r8b4 : boolean
>b4 !== a4 : boolean
>b4 : { fn(x?: string): string; }
>a4 : { fn<T>(x?: T): T; }
var r8b5 = b5 !== a5;
>r8b5 : boolean
>b5 !== a5 : boolean
>b5 : { fn(...x: string[]): string; }
>a5 : { fn<T>(...x: T[]): T; }
var r8b6 = b6 !== a6;
>r8b6 : boolean
>b6 !== a6 : boolean
>b6 : { fn(x: string, y: number): {}; }
>a6 : { fn<T>(x: T, y: T): T; }
//var r8b7 = b7 !== a7;

215
tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt
View File

@ -1,215 +0,0 @@
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(40,12): error TS2365: Operator '<' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(57,12): error TS2365: Operator '>' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(74,12): error TS2365: Operator '<=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(91,12): error TS2365: Operator '>=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(108,12): error TS2365: Operator '==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(125,12): error TS2365: Operator '!=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(142,12): error TS2365: Operator '===' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(159,12): error TS2365: Operator '!==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts (16 errors) ====
class Base {
public a: string;
}
class Derived extends Base {
public b: string;
}
var a1: { new <T>(x: T): T };
var b1: { new (x: string): string };
var a2: { new <T>(x: T): T };
var b2: { new (x: string, y: number): string };
var a3: { new <T, U>(x: T, y: U): T };
var b3: { new (x: string, y: number): string };
var a4: { new <T>(x?: T): T };
var b4: { new (x?: string): string };
var a5: { new <T>(...x: T[]): T };
var b5: { new (...x: string[]): string };
var a6: { new <T>(x: T, y: T): T };
var b6: { new (x: string, y: number): {} };
//var a7: { new <T, U extends T>(x: T, y: U): T };
var b7: { new (x: Base, y: Derived): Base };
// operator <
var r1a1 = a1 < b1;
var r1a2 = a2 < b2;
~~~~~~~
!!! error TS2365: Operator '<' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r1a3 = a3 < b3;
var r1a4 = a4 < b4;
var r1a5 = a5 < b5;
var r1a6 = a6 < b6;
//var r1a7 = a7 < b7;
var r1b1 = b1 < a1;
var r1b2 = b2 < a2;
~~~~~~~
!!! error TS2365: Operator '<' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r1b3 = b3 < a3;
var r1b4 = b4 < a4;
var r1b5 = b5 < a5;
var r1b6 = b6 < a6;
//var r1b7 = b7 < a7;
// operator >
var r2a1 = a1 > b1;
var r2a2 = a2 > b2;
~~~~~~~
!!! error TS2365: Operator '>' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r2a3 = a3 > b3;
var r2a4 = a4 > b4;
var r2a5 = a5 > b5;
var r2a6 = a6 > b6;
//var r2a7 = a7 > b7;
var r2b1 = b1 > a1;
var r2b2 = b2 > a2;
~~~~~~~
!!! error TS2365: Operator '>' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r2b3 = b3 > a3;
var r2b4 = b4 > a4;
var r2b5 = b5 > a5;
var r2b6 = b6 > a6;
//var r2b7 = b7 > a7;
// operator <=
var r3a1 = a1 <= b1;
var r3a2 = a2 <= b2;
~~~~~~~~
!!! error TS2365: Operator '<=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r3a3 = a3 <= b3;
var r3a4 = a4 <= b4;
var r3a5 = a5 <= b5;
var r3a6 = a6 <= b6;
//var r3a7 = a7 <= b7;
var r3b1 = b1 <= a1;
var r3b2 = b2 <= a2;
~~~~~~~~
!!! error TS2365: Operator '<=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r3b3 = b3 <= a3;
var r3b4 = b4 <= a4;
var r3b5 = b5 <= a5;
var r3b6 = b6 <= a6;
//var r3b7 = b7 <= a7;
// operator >=
var r4a1 = a1 >= b1;
var r4a2 = a2 >= b2;
~~~~~~~~
!!! error TS2365: Operator '>=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r4a3 = a3 >= b3;
var r4a4 = a4 >= b4;
var r4a5 = a5 >= b5;
var r4a6 = a6 >= b6;
//var r4a7 = a7 >= b7;
var r4b1 = b1 >= a1;
var r4b2 = b2 >= a2;
~~~~~~~~
!!! error TS2365: Operator '>=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r4b3 = b3 >= a3;
var r4b4 = b4 >= a4;
var r4b5 = b5 >= a5;
var r4b6 = b6 >= a6;
//var r4b7 = b7 >= a7;
// operator ==
var r5a1 = a1 == b1;
var r5a2 = a2 == b2;
~~~~~~~~
!!! error TS2365: Operator '==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r5a3 = a3 == b3;
var r5a4 = a4 == b4;
var r5a5 = a5 == b5;
var r5a6 = a6 == b6;
//var r5a7 = a7 == b7;
var r5b1 = b1 == a1;
var r5b2 = b2 == a2;
~~~~~~~~
!!! error TS2365: Operator '==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r5b3 = b3 == a3;
var r5b4 = b4 == a4;
var r5b5 = b5 == a5;
var r5b6 = b6 == a6;
//var r5b7 = b7 == a7;
// operator !=
var r6a1 = a1 != b1;
var r6a2 = a2 != b2;
~~~~~~~~
!!! error TS2365: Operator '!=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r6a3 = a3 != b3;
var r6a4 = a4 != b4;
var r6a5 = a5 != b5;
var r6a6 = a6 != b6;
//var r6a7 = a7 != b7;
var r6b1 = b1 != a1;
var r6b2 = b2 != a2;
~~~~~~~~
!!! error TS2365: Operator '!=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r6b3 = b3 != a3;
var r6b4 = b4 != a4;
var r6b5 = b5 != a5;
var r6b6 = b6 != a6;
//var r6b7 = b7 != a7;
// operator ===
var r7a1 = a1 === b1;
var r7a2 = a2 === b2;
~~~~~~~~~
!!! error TS2365: Operator '===' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r7a3 = a3 === b3;
var r7a4 = a4 === b4;
var r7a5 = a5 === b5;
var r7a6 = a6 === b6;
//var r7a7 = a7 === b7;
var r7b1 = b1 === a1;
var r7b2 = b2 === a2;
~~~~~~~~~
!!! error TS2365: Operator '===' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r7b3 = b3 === a3;
var r7b4 = b4 === a4;
var r7b5 = b5 === a5;
var r7b6 = b6 === a6;
//var r7b7 = b7 === a7;
// operator !==
var r8a1 = a1 !== b1;
var r8a2 = a2 !== b2;
~~~~~~~~~
!!! error TS2365: Operator '!==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
var r8a3 = a3 !== b3;
var r8a4 = a4 !== b4;
var r8a5 = a5 !== b5;
var r8a6 = a6 !== b6;
//var r8a7 = a7 !== b7;
var r8b1 = b1 !== a1;
var r8b2 = b2 !== a2;
~~~~~~~~~
!!! error TS2365: Operator '!==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
var r8b3 = b3 !== a3;
var r8b4 = b4 !== a4;
var r8b5 = b5 !== a5;
var r8b6 = b6 !== a6;
//var r8b7 = b7 !== a7;

714
tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types Normal file
View File

@ -0,0 +1,714 @@
=== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts ===
class Base {
>Base : Base
public a: string;
>a : string
}
class Derived extends Base {
>Derived : Derived
>Base : Base
public b: string;
>b : string
}
var a1: { new <T>(x: T): T };
>a1 : new <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
var b1: { new (x: string): string };
>b1 : new (x: string) => string
>x : string
var a2: { new <T>(x: T): T };
>a2 : new <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
var b2: { new (x: string, y: number): string };
>b2 : new (x: string, y: number) => string
>x : string
>y : number
var a3: { new <T, U>(x: T, y: U): T };
>a3 : new <T, U>(x: T, y: U) => T
>T : T
>U : U
>x : T
>T : T
>y : U
>U : U
>T : T
var b3: { new (x: string, y: number): string };
>b3 : new (x: string, y: number) => string
>x : string
>y : number
var a4: { new <T>(x?: T): T };
>a4 : new <T>(x?: T) => T
>T : T
>x : T
>T : T
>T : T
var b4: { new (x?: string): string };
>b4 : new (x?: string) => string
>x : string
var a5: { new <T>(...x: T[]): T };
>a5 : new <T>(...x: T[]) => T
>T : T
>x : T[]
>T : T
>T : T
var b5: { new (...x: string[]): string };
>b5 : new (...x: string[]) => string
>x : string[]
var a6: { new <T>(x: T, y: T): T };
>a6 : new <T>(x: T, y: T) => T
>T : T
>x : T
>T : T
>y : T
>T : T
>T : T
var b6: { new (x: string, y: number): {} };
>b6 : new (x: string, y: number) => {}
>x : string
>y : number
//var a7: { new <T, U extends T>(x: T, y: U): T };
var b7: { new (x: Base, y: Derived): Base };
>b7 : new (x: Base, y: Derived) => Base
>x : Base
>Base : Base
>y : Derived
>Derived : Derived
>Base : Base
// operator <
var r1a1 = a1 < b1;
>r1a1 : boolean
>a1 < b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r1a2 = a2 < b2;
>r1a2 : boolean
>a2 < b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r1a3 = a3 < b3;
>r1a3 : boolean
>a3 < b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r1a4 = a4 < b4;
>r1a4 : boolean
>a4 < b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r1a5 = a5 < b5;
>r1a5 : boolean
>a5 < b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r1a6 = a6 < b6;
>r1a6 : boolean
>a6 < b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r1a7 = a7 < b7;
var r1b1 = b1 < a1;
>r1b1 : boolean
>b1 < a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r1b2 = b2 < a2;
>r1b2 : boolean
>b2 < a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r1b3 = b3 < a3;
>r1b3 : boolean
>b3 < a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r1b4 = b4 < a4;
>r1b4 : boolean
>b4 < a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r1b5 = b5 < a5;
>r1b5 : boolean
>b5 < a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r1b6 = b6 < a6;
>r1b6 : boolean
>b6 < a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r1b7 = b7 < a7;
// operator >
var r2a1 = a1 > b1;
>r2a1 : boolean
>a1 > b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r2a2 = a2 > b2;
>r2a2 : boolean
>a2 > b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r2a3 = a3 > b3;
>r2a3 : boolean
>a3 > b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r2a4 = a4 > b4;
>r2a4 : boolean
>a4 > b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r2a5 = a5 > b5;
>r2a5 : boolean
>a5 > b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r2a6 = a6 > b6;
>r2a6 : boolean
>a6 > b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r2a7 = a7 > b7;
var r2b1 = b1 > a1;
>r2b1 : boolean
>b1 > a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r2b2 = b2 > a2;
>r2b2 : boolean
>b2 > a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r2b3 = b3 > a3;
>r2b3 : boolean
>b3 > a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r2b4 = b4 > a4;
>r2b4 : boolean
>b4 > a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r2b5 = b5 > a5;
>r2b5 : boolean
>b5 > a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r2b6 = b6 > a6;
>r2b6 : boolean
>b6 > a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r2b7 = b7 > a7;
// operator <=
var r3a1 = a1 <= b1;
>r3a1 : boolean
>a1 <= b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r3a2 = a2 <= b2;
>r3a2 : boolean
>a2 <= b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r3a3 = a3 <= b3;
>r3a3 : boolean
>a3 <= b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r3a4 = a4 <= b4;
>r3a4 : boolean
>a4 <= b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r3a5 = a5 <= b5;
>r3a5 : boolean
>a5 <= b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r3a6 = a6 <= b6;
>r3a6 : boolean
>a6 <= b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r3a7 = a7 <= b7;
var r3b1 = b1 <= a1;
>r3b1 : boolean
>b1 <= a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r3b2 = b2 <= a2;
>r3b2 : boolean
>b2 <= a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r3b3 = b3 <= a3;
>r3b3 : boolean
>b3 <= a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r3b4 = b4 <= a4;
>r3b4 : boolean
>b4 <= a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r3b5 = b5 <= a5;
>r3b5 : boolean
>b5 <= a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r3b6 = b6 <= a6;
>r3b6 : boolean
>b6 <= a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r3b7 = b7 <= a7;
// operator >=
var r4a1 = a1 >= b1;
>r4a1 : boolean
>a1 >= b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r4a2 = a2 >= b2;
>r4a2 : boolean
>a2 >= b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r4a3 = a3 >= b3;
>r4a3 : boolean
>a3 >= b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r4a4 = a4 >= b4;
>r4a4 : boolean
>a4 >= b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r4a5 = a5 >= b5;
>r4a5 : boolean
>a5 >= b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r4a6 = a6 >= b6;
>r4a6 : boolean
>a6 >= b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r4a7 = a7 >= b7;
var r4b1 = b1 >= a1;
>r4b1 : boolean
>b1 >= a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r4b2 = b2 >= a2;
>r4b2 : boolean
>b2 >= a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r4b3 = b3 >= a3;
>r4b3 : boolean
>b3 >= a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r4b4 = b4 >= a4;
>r4b4 : boolean
>b4 >= a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r4b5 = b5 >= a5;
>r4b5 : boolean
>b5 >= a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r4b6 = b6 >= a6;
>r4b6 : boolean
>b6 >= a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r4b7 = b7 >= a7;
// operator ==
var r5a1 = a1 == b1;
>r5a1 : boolean
>a1 == b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r5a2 = a2 == b2;
>r5a2 : boolean
>a2 == b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r5a3 = a3 == b3;
>r5a3 : boolean
>a3 == b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r5a4 = a4 == b4;
>r5a4 : boolean
>a4 == b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r5a5 = a5 == b5;
>r5a5 : boolean
>a5 == b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r5a6 = a6 == b6;
>r5a6 : boolean
>a6 == b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r5a7 = a7 == b7;
var r5b1 = b1 == a1;
>r5b1 : boolean
>b1 == a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r5b2 = b2 == a2;
>r5b2 : boolean
>b2 == a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r5b3 = b3 == a3;
>r5b3 : boolean
>b3 == a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r5b4 = b4 == a4;
>r5b4 : boolean
>b4 == a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r5b5 = b5 == a5;
>r5b5 : boolean
>b5 == a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r5b6 = b6 == a6;
>r5b6 : boolean
>b6 == a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r5b7 = b7 == a7;
// operator !=
var r6a1 = a1 != b1;
>r6a1 : boolean
>a1 != b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r6a2 = a2 != b2;
>r6a2 : boolean
>a2 != b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r6a3 = a3 != b3;
>r6a3 : boolean
>a3 != b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r6a4 = a4 != b4;
>r6a4 : boolean
>a4 != b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r6a5 = a5 != b5;
>r6a5 : boolean
>a5 != b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r6a6 = a6 != b6;
>r6a6 : boolean
>a6 != b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r6a7 = a7 != b7;
var r6b1 = b1 != a1;
>r6b1 : boolean
>b1 != a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r6b2 = b2 != a2;
>r6b2 : boolean
>b2 != a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r6b3 = b3 != a3;
>r6b3 : boolean
>b3 != a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r6b4 = b4 != a4;
>r6b4 : boolean
>b4 != a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r6b5 = b5 != a5;
>r6b5 : boolean
>b5 != a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r6b6 = b6 != a6;
>r6b6 : boolean
>b6 != a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r6b7 = b7 != a7;
// operator ===
var r7a1 = a1 === b1;
>r7a1 : boolean
>a1 === b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r7a2 = a2 === b2;
>r7a2 : boolean
>a2 === b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r7a3 = a3 === b3;
>r7a3 : boolean
>a3 === b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r7a4 = a4 === b4;
>r7a4 : boolean
>a4 === b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r7a5 = a5 === b5;
>r7a5 : boolean
>a5 === b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r7a6 = a6 === b6;
>r7a6 : boolean
>a6 === b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r7a7 = a7 === b7;
var r7b1 = b1 === a1;
>r7b1 : boolean
>b1 === a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r7b2 = b2 === a2;
>r7b2 : boolean
>b2 === a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r7b3 = b3 === a3;
>r7b3 : boolean
>b3 === a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r7b4 = b4 === a4;
>r7b4 : boolean
>b4 === a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r7b5 = b5 === a5;
>r7b5 : boolean
>b5 === a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r7b6 = b6 === a6;
>r7b6 : boolean
>b6 === a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r7b7 = b7 === a7;
// operator !==
var r8a1 = a1 !== b1;
>r8a1 : boolean
>a1 !== b1 : boolean
>a1 : new <T>(x: T) => T
>b1 : new (x: string) => string
var r8a2 = a2 !== b2;
>r8a2 : boolean
>a2 !== b2 : boolean
>a2 : new <T>(x: T) => T
>b2 : new (x: string, y: number) => string
var r8a3 = a3 !== b3;
>r8a3 : boolean
>a3 !== b3 : boolean
>a3 : new <T, U>(x: T, y: U) => T
>b3 : new (x: string, y: number) => string
var r8a4 = a4 !== b4;
>r8a4 : boolean
>a4 !== b4 : boolean
>a4 : new <T>(x?: T) => T
>b4 : new (x?: string) => string
var r8a5 = a5 !== b5;
>r8a5 : boolean
>a5 !== b5 : boolean
>a5 : new <T>(...x: T[]) => T
>b5 : new (...x: string[]) => string
var r8a6 = a6 !== b6;
>r8a6 : boolean
>a6 !== b6 : boolean
>a6 : new <T>(x: T, y: T) => T
>b6 : new (x: string, y: number) => {}
//var r8a7 = a7 !== b7;
var r8b1 = b1 !== a1;
>r8b1 : boolean
>b1 !== a1 : boolean
>b1 : new (x: string) => string
>a1 : new <T>(x: T) => T
var r8b2 = b2 !== a2;
>r8b2 : boolean
>b2 !== a2 : boolean
>b2 : new (x: string, y: number) => string
>a2 : new <T>(x: T) => T
var r8b3 = b3 !== a3;
>r8b3 : boolean
>b3 !== a3 : boolean
>b3 : new (x: string, y: number) => string
>a3 : new <T, U>(x: T, y: U) => T
var r8b4 = b4 !== a4;
>r8b4 : boolean
>b4 !== a4 : boolean
>b4 : new (x?: string) => string
>a4 : new <T>(x?: T) => T
var r8b5 = b5 !== a5;
>r8b5 : boolean
>b5 !== a5 : boolean
>b5 : new (...x: string[]) => string
>a5 : new <T>(...x: T[]) => T
var r8b6 = b6 !== a6;
>r8b6 : boolean
>b6 !== a6 : boolean
>b6 : new (x: string, y: number) => {}
>a6 : new <T>(x: T, y: T) => T
//var r8b7 = b7 !== a7;

112
tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt Normal file
View File

@ -0,0 +1,112 @@
tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(58,1): error TS2354: No best common type exists among return expressions.
tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(67,1): error TS2354: No best common type exists among return expressions.
==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (2 errors) ====
// return type of a function with multiple returns is the BCT of each return statement
// no errors expected here
function f1() {
if (true) {
return 1;
} else {
return null;
}
}
function f2() {
if (true) {
return 1;
} else if (false) {
return null;
} else {
return 2;
}
}
function f4() {
try {
return 1;
}
catch (e) {
return undefined;
}
finally {
return 1;
}
}
function f5() {
return 1;
return new Object();
}
function f6<T>(x: T) {
if (true) {
return x;
} else {
return null;
}
}
//function f7<T extends U, U>(x: T, y: U) {
// if (true) {
// return x;
// } else {
// return y;
// }
//}
var a: { x: number; y?: number };
var b: { x: number; z?: number };
// returns typeof a
function f9() {
~~~~~~~~~~~~~~~
if (true) {
~~~~~~~~~~~~~~~
return a;
~~~~~~~~~~~~~~~~~
} else {
~~~~~~~~~~~~
return b;
~~~~~~~~~~~~~~~~~
}
~~~~~
}
~
!!! error TS2354: No best common type exists among return expressions.
// returns typeof b
function f10() {
~~~~~~~~~~~~~~~~
if (true) {
~~~~~~~~~~~~~~~
return b;
~~~~~~~~~~~~~~~~~
} else {
~~~~~~~~~~~~
return a;
~~~~~~~~~~~~~~~~~
}
~~~~~
}
~
!!! error TS2354: No best common type exists among return expressions.
// returns number => void
function f11() {
if (true) {
return (x: number) => { }
} else {
return (x: Object) => { }
}
}
// returns Object => void
function f12() {
if (true) {
return (x: Object) => { }
} else {
return (x: number) => { }
}
}

146
tests/baselines/reference/functionWithMultipleReturnStatements2.types
View File

@ -1,146 +0,0 @@
=== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts ===
// return type of a function with multiple returns is the BCT of each return statement
// no errors expected here
function f1() {
>f1 : () => number
if (true) {
return 1;
} else {
return null;
}
}
function f2() {
>f2 : () => number
if (true) {
return 1;
} else if (false) {
return null;
} else {
return 2;
}
}
function f4() {
>f4 : () => number
try {
return 1;
}
catch (e) {
>e : any
return undefined;
>undefined : undefined
}
finally {
return 1;
}
}
function f5() {
>f5 : () => Object
return 1;
return new Object();
>new Object() : Object
>Object : { (): any; (value: any): any; new (value?: any): Object; prototype: Object; getPrototypeOf(o: any): any; getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; getOwnPropertyNames(o: any): string[]; create(o: any, properties?: PropertyDescriptorMap): any; defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; defineProperties(o: any, properties: PropertyDescriptorMap): any; seal(o: any): any; freeze(o: any): any; preventExtensions(o: any): any; isSealed(o: any): boolean; isFrozen(o: any): boolean; isExtensible(o: any): boolean; keys(o: any): string[]; }
}
function f6<T>(x: T) {
>f6 : <T>(x: T) => T
>T : T
>x : T
>T : T
if (true) {
return x;
>x : T
} else {
return null;
}
}
//function f7<T extends U, U>(x: T, y: U) {
// if (true) {
// return x;
// } else {
// return y;
// }
//}
var a: { x: number; y?: number };
>a : { x: number; y?: number; }
>x : number
>y : number
var b: { x: number; z?: number };
>b : { x: number; z?: number; }
>x : number
>z : number
// returns typeof a
function f9() {
>f9 : () => { x: number; y?: number; }
if (true) {
return a;
>a : { x: number; y?: number; }
} else {
return b;
>b : { x: number; z?: number; }
}
}
// returns typeof b
function f10() {
>f10 : () => { x: number; z?: number; }
if (true) {
return b;
>b : { x: number; z?: number; }
} else {
return a;
>a : { x: number; y?: number; }
}
}
// returns number => void
function f11() {
>f11 : () => (x: number) => void
if (true) {
return (x: number) => { }
>(x: number) => { } : (x: number) => void
>x : number
} else {
return (x: Object) => { }
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object
}
}
// returns Object => void
function f12() {
>f12 : () => (x: Object) => void
if (true) {
return (x: Object) => { }
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object
} else {
return (x: number) => { }
>(x: number) => { } : (x: number) => void
>x : number
}
}

51
tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt Normal file
View File

@ -0,0 +1,51 @@
tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts(18,10): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts(19,10): error TS2346: Supplied parameters do not match any signature of call target.
==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts (2 errors) ====
// When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made,
// the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
function foo<T>(a: (x: T) => T, b: (x: T) => T) {
var r: (x: T) => T;
return r;
}
//var r1 = foo((x: number) => 1, (x: string) => ''); // error
var r1b = foo((x) => 1, (x) => ''); // {} => {}
var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object
var r3 = foo((x: number) => 1, (x: Object) => null); // number => number
var r3ii = foo((x: number) => 1, (x: number) => 1); // number => number
var a: { x: number; y?: number; };
var b: { x: number; z?: number; };
var r4 = foo((x: typeof a) => a, (x: typeof b) => b); // typeof a => typeof a
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2346: Supplied parameters do not match any signature of call target.
var r5 = foo((x: typeof b) => b, (x: typeof a) => a); // typeof b => typeof b
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2346: Supplied parameters do not match any signature of call target.
function other<T>(x: T) {
var r6 = foo((a: T) => a, (b: T) => b); // T => T
var r6b = foo((a) => a, (b) => b); // {} => {}
}
function other2<T extends Date>(x: T) {
var r7 = foo((a: T) => a, (b: T) => b); // T => T
var r7b = foo((a) => a, (b) => b); // {} => {}
var r8 = r7(null);
// BUG 835518
//var r9 = r7(new Date());
}
function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
var r: (x: T) => T;
return r;
}
function other3<T extends RegExp>(x: T) {
var r8 = foo2((a: Date) => a, (b: Date) => b); // Date => Date
}

216
tests/baselines/reference/genericCallWithGenericSignatureArguments.types
View File

@ -1,216 +0,0 @@
=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts ===
// When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made,
// the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
function foo<T>(a: (x: T) => T, b: (x: T) => T) {
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>T : T
>a : (x: T) => T
>x : T
>T : T
>T : T
>b : (x: T) => T
>x : T
>T : T
>T : T
var r: (x: T) => T;
>r : (x: T) => T
>x : T
>T : T
>T : T
return r;
>r : (x: T) => T
}
//var r1 = foo((x: number) => 1, (x: string) => ''); // error
var r1b = foo((x) => 1, (x) => ''); // {} => {}
>r1b : (x: {}) => {}
>foo((x) => 1, (x) => '') : (x: {}) => {}
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x) => 1 : (x: {}) => number
>x : {}
>(x) => '' : (x: {}) => string
>x : {}
var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object
>r2 : (x: any) => any
>foo((x: Object) => null, (x: string) => '') : (x: any) => any
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x: Object) => null : (x: Object) => any
>x : Object
>Object : Object
>(x: string) => '' : (x: string) => string
>x : string
var r3 = foo((x: number) => 1, (x: Object) => null); // number => number
>r3 : (x: any) => any
>foo((x: number) => 1, (x: Object) => null) : (x: any) => any
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x: number) => 1 : (x: number) => number
>x : number
>(x: Object) => null : (x: Object) => any
>x : Object
>Object : Object
var r3ii = foo((x: number) => 1, (x: number) => 1); // number => number
>r3ii : (x: number) => number
>foo((x: number) => 1, (x: number) => 1) : (x: number) => number
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x: number) => 1 : (x: number) => number
>x : number
>(x: number) => 1 : (x: number) => number
>x : number
var a: { x: number; y?: number; };
>a : { x: number; y?: number; }
>x : number
>y : number
var b: { x: number; z?: number; };
>b : { x: number; z?: number; }
>x : number
>z : number
var r4 = foo((x: typeof a) => a, (x: typeof b) => b); // typeof a => typeof a
>r4 : (x: { x: number; y?: number; }) => { x: number; y?: number; }
>foo((x: typeof a) => a, (x: typeof b) => b) : (x: { x: number; y?: number; }) => { x: number; y?: number; }
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x: typeof a) => a : (x: { x: number; y?: number; }) => { x: number; y?: number; }
>x : { x: number; y?: number; }
>a : { x: number; y?: number; }
>a : { x: number; y?: number; }
>(x: typeof b) => b : (x: { x: number; z?: number; }) => { x: number; z?: number; }
>x : { x: number; z?: number; }
>b : { x: number; z?: number; }
>b : { x: number; z?: number; }
var r5 = foo((x: typeof b) => b, (x: typeof a) => a); // typeof b => typeof b
>r5 : (x: { x: number; z?: number; }) => { x: number; z?: number; }
>foo((x: typeof b) => b, (x: typeof a) => a) : (x: { x: number; z?: number; }) => { x: number; z?: number; }
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(x: typeof b) => b : (x: { x: number; z?: number; }) => { x: number; z?: number; }
>x : { x: number; z?: number; }
>b : { x: number; z?: number; }
>b : { x: number; z?: number; }
>(x: typeof a) => a : (x: { x: number; y?: number; }) => { x: number; y?: number; }
>x : { x: number; y?: number; }
>a : { x: number; y?: number; }
>a : { x: number; y?: number; }
function other<T>(x: T) {
>other : <T>(x: T) => void
>T : T
>x : T
>T : T
var r6 = foo((a: T) => a, (b: T) => b); // T => T
>r6 : (x: T) => T
>foo((a: T) => a, (b: T) => b) : (x: T) => T
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(a: T) => a : (a: T) => T
>a : T
>T : T
>a : T
>(b: T) => b : (b: T) => T
>b : T
>T : T
>b : T
var r6b = foo((a) => a, (b) => b); // {} => {}
>r6b : (x: {}) => {}
>foo((a) => a, (b) => b) : (x: {}) => {}
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(a) => a : (a: {}) => {}
>a : {}
>a : {}
>(b) => b : (b: {}) => {}
>b : {}
>b : {}
}
function other2<T extends Date>(x: T) {
>other2 : <T extends Date>(x: T) => void
>T : T
>Date : Date
>x : T
>T : T
var r7 = foo((a: T) => a, (b: T) => b); // T => T
>r7 : (x: T) => T
>foo((a: T) => a, (b: T) => b) : (x: T) => T
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(a: T) => a : (a: T) => T
>a : T
>T : T
>a : T
>(b: T) => b : (b: T) => T
>b : T
>T : T
>b : T
var r7b = foo((a) => a, (b) => b); // {} => {}
>r7b : (x: {}) => {}
>foo((a) => a, (b) => b) : (x: {}) => {}
>foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(a) => a : (a: {}) => {}
>a : {}
>a : {}
>(b) => b : (b: {}) => {}
>b : {}
>b : {}
var r8 = r7(null);
>r8 : T
>r7(null) : T
>r7 : (x: T) => T
// BUG 835518
//var r9 = r7(new Date());
}
function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
>foo2 : <T extends Date>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>T : T
>Date : Date
>a : (x: T) => T
>x : T
>T : T
>T : T
>b : (x: T) => T
>x : T
>T : T
>T : T
var r: (x: T) => T;
>r : (x: T) => T
>x : T
>T : T
>T : T
return r;
>r : (x: T) => T
}
function other3<T extends RegExp>(x: T) {
>other3 : <T extends RegExp>(x: T) => void
>T : T
>RegExp : RegExp
>x : T
>T : T
var r8 = foo2((a: Date) => a, (b: Date) => b); // Date => Date
>r8 : (x: Date) => Date
>foo2((a: Date) => a, (b: Date) => b) : (x: Date) => Date
>foo2 : <T extends Date>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
>(a: Date) => a : (a: Date) => Date
>a : Date
>Date : Date
>a : Date
>(b: Date) => b : (b: Date) => Date
>b : Date
>Date : Date
>b : Date
}

40
tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt Normal file
View File

@ -0,0 +1,40 @@
tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts(12,9): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts(13,10): error TS2346: Supplied parameters do not match any signature of call target.
==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts (2 errors) ====
// generic type argument inference where inference leads to two candidates that are both supertypes of all candidates
// we choose the first candidate so the result is dependent on the order of the arguments provided
function foo<T>(x: T, y: T) {
var r: T;
return r;
}
var a: { x: number; y?: number; };
var b: { x: number; z?: number; };
var r = foo(a, b); // { x: number; y?: number; };
~~~~~~~~~
!!! error TS2346: Supplied parameters do not match any signature of call target.
var r2 = foo(b, a); // { x: number; z?: number; };
~~~~~~~~~
!!! error TS2346: Supplied parameters do not match any signature of call target.
var x: { x: number; };
var y: { x?: number; };
var r3 = foo(a, x); // { x: number; y?: number; };
var r4 = foo(x, a); // { x: number; };
var r5 = foo(a, y); // { x?: number; };
var r5 = foo(y, a); // { x?: number; };
var r6 = foo(x, y); // { x?: number; };
var r6 = foo(y, x); // { x?: number; };
var s1: (x: Object) => string;
var s2: (x: string) => string;
var r7 = foo(s1, s2); // (x: Object) => string;
var r8 = foo(s2, s1); // (x: string) => string;

117
tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types
View File

@ -1,117 +0,0 @@
=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts ===
// generic type argument inference where inference leads to two candidates that are both supertypes of all candidates
// we choose the first candidate so the result is dependent on the order of the arguments provided
function foo<T>(x: T, y: T) {
>foo : <T>(x: T, y: T) => T
>T : T
>x : T
>T : T
>y : T
>T : T
var r: T;
>r : T
>T : T
return r;
>r : T
}
var a: { x: number; y?: number; };
>a : { x: number; y?: number; }
>x : number
>y : number
var b: { x: number; z?: number; };
>b : { x: number; z?: number; }
>x : number
>z : number
var r = foo(a, b); // { x: number; y?: number; };
>r : { x: number; y?: number; }
>foo(a, b) : { x: number; y?: number; }
>foo : <T>(x: T, y: T) => T
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }
var r2 = foo(b, a); // { x: number; z?: number; };
>r2 : { x: number; z?: number; }
>foo(b, a) : { x: number; z?: number; }
>foo : <T>(x: T, y: T) => T
>b : { x: number; z?: number; }
>a : { x: number; y?: number; }
var x: { x: number; };
>x : { x: number; }
>x : number
var y: { x?: number; };
>y : { x?: number; }
>x : number
var r3 = foo(a, x); // { x: number; y?: number; };
>r3 : { x: number; y?: number; }
>foo(a, x) : { x: number; y?: number; }
>foo : <T>(x: T, y: T) => T
>a : { x: number; y?: number; }
>x : { x: number; }
var r4 = foo(x, a); // { x: number; };
>r4 : { x: number; }
>foo(x, a) : { x: number; }
>foo : <T>(x: T, y: T) => T
>x : { x: number; }
>a : { x: number; y?: number; }
var r5 = foo(a, y); // { x?: number; };
>r5 : { x?: number; }
>foo(a, y) : { x?: number; }
>foo : <T>(x: T, y: T) => T
>a : { x: number; y?: number; }
>y : { x?: number; }
var r5 = foo(y, a); // { x?: number; };
>r5 : { x?: number; }
>foo(y, a) : { x?: number; }
>foo : <T>(x: T, y: T) => T
>y : { x?: number; }
>a : { x: number; y?: number; }
var r6 = foo(x, y); // { x?: number; };
>r6 : { x?: number; }
>foo(x, y) : { x?: number; }
>foo : <T>(x: T, y: T) => T
>x : { x: number; }
>y : { x?: number; }
var r6 = foo(y, x); // { x?: number; };
>r6 : { x?: number; }
>foo(y, x) : { x?: number; }
>foo : <T>(x: T, y: T) => T
>y : { x?: number; }
>x : { x: number; }
var s1: (x: Object) => string;
>s1 : (x: Object) => string
>x : Object
>Object : Object
var s2: (x: string) => string;
>s2 : (x: string) => string
>x : string
var r7 = foo(s1, s2); // (x: Object) => string;
>r7 : (x: Object) => string
>foo(s1, s2) : (x: Object) => string
>foo : <T>(x: T, y: T) => T
>s1 : (x: Object) => string
>s2 : (x: string) => string
var r8 = foo(s2, s1); // (x: string) => string;
>r8 : (x: string) => string
>foo(s2, s1) : (x: string) => string
>foo : <T>(x: T, y: T) => T
>s2 : (x: string) => string
>s1 : (x: Object) => string

4
tests/baselines/reference/subtypingWithObjectMembersOptionality3.types
View File

@ -69,8 +69,8 @@ var b: { Foo2: Derived; }
>Derived : Derived
var r = true ? a : b; // ok
>r : { Foo?: Base; }
>true ? a : b : { Foo?: Base; }
>r : { Foo?: Base; } | { Foo2: Derived; }
>true ? a : b : { Foo?: Base; } | { Foo2: Derived; }
>a : { Foo?: Base; }
>b : { Foo2: Derived; }

4
tests/baselines/reference/subtypingWithObjectMembersOptionality4.types
View File

@ -69,8 +69,8 @@ var b: { Foo2?: Derived; }
>Derived : Derived
var r = true ? a : b; // ok
>r : { Foo2?: Derived; }
>true ? a : b : { Foo2?: Derived; }
>r : { Foo: Base; } | { Foo2?: Derived; }
>true ? a : b : { Foo: Base; } | { Foo2?: Derived; }
>a : { Foo: Base; }
>b : { Foo2?: Derived; }