From 81eaae0afa37ff150456ccc058a153ebb0f0c428 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 19 Oct 2014 16:43:32 -0700 Subject: [PATCH 1/3] Require optional properties to be present in subtypes Remove unused getBestCommonType method (unrelated change) --- src/compiler/checker.ts | 8 ++------ src/compiler/emitter.ts | 4 ++-- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e29bb7499da..e87d3d70a37 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3357,7 +3357,7 @@ module ts { var sourceProp = getPropertyOfApparentType(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)); } @@ -3646,10 +3646,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; } @@ -5736,7 +5732,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; diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 57deae0b8f2..4dda5c92ca7 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2868,7 +2868,7 @@ module ts { } return { diagnosticMessage: diagnosticMessage, - errorNode: node.parameters[0], + errorNode: node.parameters[0], typeName: node.name }; } @@ -2889,7 +2889,7 @@ module ts { } return { diagnosticMessage: diagnosticMessage, - errorNode: node.name, + errorNode: node.name, typeName: undefined }; } From 40d12a0995ddb7beefecccb4931fbe2f367238d5 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 19 Oct 2014 16:44:32 -0700 Subject: [PATCH 2/3] Accepting new baselines --- ...ayLiteralWithMultipleBestCommonTypes.types | 20 +- ...stCommonTypeOfConditionalExpressions.types | 8 +- ...jectOnInstantiatedCallSignature.errors.txt | 215 ------ ...ypeObjectOnInstantiatedCallSignature.types | 727 ++++++++++++++++++ ...nstantiatedConstructorSignature.errors.txt | 215 ------ ...ctOnInstantiatedConstructorSignature.types | 714 +++++++++++++++++ ...onWithMultipleReturnStatements2.errors.txt | 112 +++ ...unctionWithMultipleReturnStatements2.types | 146 ---- ...llWithGenericSignatureArguments.errors.txt | 51 ++ ...ricCallWithGenericSignatureArguments.types | 216 ------ ...ricCallWithNonSymmetricSubtypes.errors.txt | 40 + .../genericCallWithNonSymmetricSubtypes.types | 117 --- ...btypingWithObjectMembersOptionality3.types | 4 +- ...btypingWithObjectMembersOptionality4.types | 4 +- 14 files changed, 1662 insertions(+), 927 deletions(-) delete mode 100644 tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt create mode 100644 tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types delete mode 100644 tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt create mode 100644 tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types create mode 100644 tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt delete mode 100644 tests/baselines/reference/functionWithMultipleReturnStatements2.types create mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt delete mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments.types create mode 100644 tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt delete mode 100644 tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types index 49b65a86aa6..85a74088391 100644 --- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types +++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types @@ -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 : Array<{ x: number; y?: number; } | { x: number; z?: number; }> +>[a, b] : Array<{ 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 : Array<{ x: number; y?: number; } | { x: number; z?: number; }> +>[b, a] : Array<{ 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 : Array<{ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; }> +>[a, b, c] : Array<{ 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 : Array<{ (a: { x: number; y?: number; }): number; } | { (b: { x: number; z?: number; }): number; }> +>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : Array<{ (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 : Array<{ (b: { x: number; z?: number; }): number; } | { (a: { x: number; y?: number; }): number; }> +>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : Array<{ (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 diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types index 2c3ba8bc7c7..eb94c140883 100644 --- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types +++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types @@ -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; } diff --git a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt deleted file mode 100644 index 2e63bf0a795..00000000000 --- a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt +++ /dev/null @@ -1,215 +0,0 @@ -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types '{ fn(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(x: T): T; }'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types '{ fn(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(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(x: T): T }; - var b1: { fn(x: string): string }; - - var a2: { fn(x: T): T }; - var b2: { fn(x: string, y: number): string }; - - var a3: { fn(x: T, y: U): T }; - var b3: { fn(x: string, y: number): string }; - - var a4: { fn(x?: T): T }; - var b4: { fn(x?: string): string }; - - var a5: { fn(...x: T[]): T }; - var b5: { fn(...x: string[]): string }; - - var a6: { fn(x: T, y: T): T }; - var b6: { fn(x: string, y: number): {} }; - - //var a7: { fn(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(x: T): T; }'. - var r8b3 = b3 !== a3; - var r8b4 = b4 !== a4; - var r8b5 = b5 !== a5; - var r8b6 = b6 !== a6; - //var r8b7 = b7 !== a7; \ No newline at end of file diff --git a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types new file mode 100644 index 00000000000..c3f0d96e839 --- /dev/null +++ b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types @@ -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(x: T): T }; +>a1 : { fn(x: T): T; } +>fn : (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(x: T): T }; +>a2 : { fn(x: T): T; } +>fn : (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(x: T, y: U): T }; +>a3 : { fn(x: T, y: U): T; } +>fn : (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(x?: T): T }; +>a4 : { fn(x?: T): T; } +>fn : (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(...x: T[]): T }; +>a5 : { fn(...x: T[]): T; } +>fn : (...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(x: T, y: T): T }; +>a6 : { fn(x: T, y: T): T; } +>fn : (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(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(x: T): T; } +>b1 : { fn(x: string): string; } + +var r1a2 = a2 < b2; +>r1a2 : boolean +>a2 < b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r1a3 = a3 < b3; +>r1a3 : boolean +>a3 < b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r1a4 = a4 < b4; +>r1a4 : boolean +>a4 < b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r1a5 = a5 < b5; +>r1a5 : boolean +>a5 < b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r1a6 = a6 < b6; +>r1a6 : boolean +>a6 < b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r1b2 = b2 < a2; +>r1b2 : boolean +>b2 < a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r1b3 = b3 < a3; +>r1b3 : boolean +>b3 < a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r1b4 = b4 < a4; +>r1b4 : boolean +>b4 < a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r1b5 = b5 < a5; +>r1b5 : boolean +>b5 < a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r1b6 = b6 < a6; +>r1b6 : boolean +>b6 < a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r1b7 = b7 < a7; + +// operator > +var r2a1 = a1 > b1; +>r2a1 : boolean +>a1 > b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r2a2 = a2 > b2; +>r2a2 : boolean +>a2 > b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r2a3 = a3 > b3; +>r2a3 : boolean +>a3 > b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r2a4 = a4 > b4; +>r2a4 : boolean +>a4 > b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r2a5 = a5 > b5; +>r2a5 : boolean +>a5 > b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r2a6 = a6 > b6; +>r2a6 : boolean +>a6 > b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r2b2 = b2 > a2; +>r2b2 : boolean +>b2 > a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r2b3 = b3 > a3; +>r2b3 : boolean +>b3 > a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r2b4 = b4 > a4; +>r2b4 : boolean +>b4 > a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r2b5 = b5 > a5; +>r2b5 : boolean +>b5 > a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r2b6 = b6 > a6; +>r2b6 : boolean +>b6 > a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r2b7 = b7 > a7; + +// operator <= +var r3a1 = a1 <= b1; +>r3a1 : boolean +>a1 <= b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r3a2 = a2 <= b2; +>r3a2 : boolean +>a2 <= b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r3a3 = a3 <= b3; +>r3a3 : boolean +>a3 <= b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r3a4 = a4 <= b4; +>r3a4 : boolean +>a4 <= b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r3a5 = a5 <= b5; +>r3a5 : boolean +>a5 <= b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r3a6 = a6 <= b6; +>r3a6 : boolean +>a6 <= b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r3b2 = b2 <= a2; +>r3b2 : boolean +>b2 <= a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r3b3 = b3 <= a3; +>r3b3 : boolean +>b3 <= a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r3b4 = b4 <= a4; +>r3b4 : boolean +>b4 <= a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r3b5 = b5 <= a5; +>r3b5 : boolean +>b5 <= a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r3b6 = b6 <= a6; +>r3b6 : boolean +>b6 <= a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r3b7 = b7 <= a7; + +// operator >= +var r4a1 = a1 >= b1; +>r4a1 : boolean +>a1 >= b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r4a2 = a2 >= b2; +>r4a2 : boolean +>a2 >= b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r4a3 = a3 >= b3; +>r4a3 : boolean +>a3 >= b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r4a4 = a4 >= b4; +>r4a4 : boolean +>a4 >= b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r4a5 = a5 >= b5; +>r4a5 : boolean +>a5 >= b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r4a6 = a6 >= b6; +>r4a6 : boolean +>a6 >= b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r4b2 = b2 >= a2; +>r4b2 : boolean +>b2 >= a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r4b3 = b3 >= a3; +>r4b3 : boolean +>b3 >= a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r4b4 = b4 >= a4; +>r4b4 : boolean +>b4 >= a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r4b5 = b5 >= a5; +>r4b5 : boolean +>b5 >= a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r4b6 = b6 >= a6; +>r4b6 : boolean +>b6 >= a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r4b7 = b7 >= a7; + +// operator == +var r5a1 = a1 == b1; +>r5a1 : boolean +>a1 == b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r5a2 = a2 == b2; +>r5a2 : boolean +>a2 == b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r5a3 = a3 == b3; +>r5a3 : boolean +>a3 == b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r5a4 = a4 == b4; +>r5a4 : boolean +>a4 == b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r5a5 = a5 == b5; +>r5a5 : boolean +>a5 == b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r5a6 = a6 == b6; +>r5a6 : boolean +>a6 == b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r5b2 = b2 == a2; +>r5b2 : boolean +>b2 == a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r5b3 = b3 == a3; +>r5b3 : boolean +>b3 == a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r5b4 = b4 == a4; +>r5b4 : boolean +>b4 == a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r5b5 = b5 == a5; +>r5b5 : boolean +>b5 == a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r5b6 = b6 == a6; +>r5b6 : boolean +>b6 == a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r5b7 = b7 == a7; + +// operator != +var r6a1 = a1 != b1; +>r6a1 : boolean +>a1 != b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r6a2 = a2 != b2; +>r6a2 : boolean +>a2 != b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r6a3 = a3 != b3; +>r6a3 : boolean +>a3 != b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r6a4 = a4 != b4; +>r6a4 : boolean +>a4 != b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r6a5 = a5 != b5; +>r6a5 : boolean +>a5 != b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r6a6 = a6 != b6; +>r6a6 : boolean +>a6 != b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r6b2 = b2 != a2; +>r6b2 : boolean +>b2 != a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r6b3 = b3 != a3; +>r6b3 : boolean +>b3 != a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r6b4 = b4 != a4; +>r6b4 : boolean +>b4 != a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r6b5 = b5 != a5; +>r6b5 : boolean +>b5 != a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r6b6 = b6 != a6; +>r6b6 : boolean +>b6 != a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r6b7 = b7 != a7; + +// operator === +var r7a1 = a1 === b1; +>r7a1 : boolean +>a1 === b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r7a2 = a2 === b2; +>r7a2 : boolean +>a2 === b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r7a3 = a3 === b3; +>r7a3 : boolean +>a3 === b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r7a4 = a4 === b4; +>r7a4 : boolean +>a4 === b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r7a5 = a5 === b5; +>r7a5 : boolean +>a5 === b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r7a6 = a6 === b6; +>r7a6 : boolean +>a6 === b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r7b2 = b2 === a2; +>r7b2 : boolean +>b2 === a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r7b3 = b3 === a3; +>r7b3 : boolean +>b3 === a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r7b4 = b4 === a4; +>r7b4 : boolean +>b4 === a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r7b5 = b5 === a5; +>r7b5 : boolean +>b5 === a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r7b6 = b6 === a6; +>r7b6 : boolean +>b6 === a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r7b7 = b7 === a7; + +// operator !== +var r8a1 = a1 !== b1; +>r8a1 : boolean +>a1 !== b1 : boolean +>a1 : { fn(x: T): T; } +>b1 : { fn(x: string): string; } + +var r8a2 = a2 !== b2; +>r8a2 : boolean +>a2 !== b2 : boolean +>a2 : { fn(x: T): T; } +>b2 : { fn(x: string, y: number): string; } + +var r8a3 = a3 !== b3; +>r8a3 : boolean +>a3 !== b3 : boolean +>a3 : { fn(x: T, y: U): T; } +>b3 : { fn(x: string, y: number): string; } + +var r8a4 = a4 !== b4; +>r8a4 : boolean +>a4 !== b4 : boolean +>a4 : { fn(x?: T): T; } +>b4 : { fn(x?: string): string; } + +var r8a5 = a5 !== b5; +>r8a5 : boolean +>a5 !== b5 : boolean +>a5 : { fn(...x: T[]): T; } +>b5 : { fn(...x: string[]): string; } + +var r8a6 = a6 !== b6; +>r8a6 : boolean +>a6 !== b6 : boolean +>a6 : { fn(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(x: T): T; } + +var r8b2 = b2 !== a2; +>r8b2 : boolean +>b2 !== a2 : boolean +>b2 : { fn(x: string, y: number): string; } +>a2 : { fn(x: T): T; } + +var r8b3 = b3 !== a3; +>r8b3 : boolean +>b3 !== a3 : boolean +>b3 : { fn(x: string, y: number): string; } +>a3 : { fn(x: T, y: U): T; } + +var r8b4 = b4 !== a4; +>r8b4 : boolean +>b4 !== a4 : boolean +>b4 : { fn(x?: string): string; } +>a4 : { fn(x?: T): T; } + +var r8b5 = b5 !== a5; +>r8b5 : boolean +>b5 !== a5 : boolean +>b5 : { fn(...x: string[]): string; } +>a5 : { fn(...x: T[]): T; } + +var r8b6 = b6 !== a6; +>r8b6 : boolean +>b6 !== a6 : boolean +>b6 : { fn(x: string, y: number): {}; } +>a6 : { fn(x: T, y: T): T; } + +//var r8b7 = b7 !== a7; diff --git a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt deleted file mode 100644 index 0e352ebcc9d..00000000000 --- a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt +++ /dev/null @@ -1,215 +0,0 @@ -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types 'new (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 (x: T) => T'. -tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types 'new (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 (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 (x: T): T }; - var b1: { new (x: string): string }; - - var a2: { new (x: T): T }; - var b2: { new (x: string, y: number): string }; - - var a3: { new (x: T, y: U): T }; - var b3: { new (x: string, y: number): string }; - - var a4: { new (x?: T): T }; - var b4: { new (x?: string): string }; - - var a5: { new (...x: T[]): T }; - var b5: { new (...x: string[]): string }; - - var a6: { new (x: T, y: T): T }; - var b6: { new (x: string, y: number): {} }; - - //var a7: { new (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (x: T) => T'. - var r8b3 = b3 !== a3; - var r8b4 = b4 !== a4; - var r8b5 = b5 !== a5; - var r8b6 = b6 !== a6; - //var r8b7 = b7 !== a7; \ No newline at end of file diff --git a/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types new file mode 100644 index 00000000000..29d92c25726 --- /dev/null +++ b/tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types @@ -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 (x: T): T }; +>a1 : new (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 (x: T): T }; +>a2 : new (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 (x: T, y: U): T }; +>a3 : new (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 (x?: T): T }; +>a4 : new (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 (...x: T[]): T }; +>a5 : new (...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 (x: T, y: T): T }; +>a6 : new (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 (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 (x: T) => T +>b1 : new (x: string) => string + +var r1a2 = a2 < b2; +>r1a2 : boolean +>a2 < b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r1a3 = a3 < b3; +>r1a3 : boolean +>a3 < b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r1a4 = a4 < b4; +>r1a4 : boolean +>a4 < b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r1a5 = a5 < b5; +>r1a5 : boolean +>a5 < b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r1a6 = a6 < b6; +>r1a6 : boolean +>a6 < b6 : boolean +>a6 : new (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 (x: T) => T + +var r1b2 = b2 < a2; +>r1b2 : boolean +>b2 < a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r1b3 = b3 < a3; +>r1b3 : boolean +>b3 < a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r1b4 = b4 < a4; +>r1b4 : boolean +>b4 < a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r1b5 = b5 < a5; +>r1b5 : boolean +>b5 < a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r1b6 = b6 < a6; +>r1b6 : boolean +>b6 < a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r1b7 = b7 < a7; + +// operator > +var r2a1 = a1 > b1; +>r2a1 : boolean +>a1 > b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r2a2 = a2 > b2; +>r2a2 : boolean +>a2 > b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r2a3 = a3 > b3; +>r2a3 : boolean +>a3 > b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r2a4 = a4 > b4; +>r2a4 : boolean +>a4 > b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r2a5 = a5 > b5; +>r2a5 : boolean +>a5 > b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r2a6 = a6 > b6; +>r2a6 : boolean +>a6 > b6 : boolean +>a6 : new (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 (x: T) => T + +var r2b2 = b2 > a2; +>r2b2 : boolean +>b2 > a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r2b3 = b3 > a3; +>r2b3 : boolean +>b3 > a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r2b4 = b4 > a4; +>r2b4 : boolean +>b4 > a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r2b5 = b5 > a5; +>r2b5 : boolean +>b5 > a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r2b6 = b6 > a6; +>r2b6 : boolean +>b6 > a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r2b7 = b7 > a7; + +// operator <= +var r3a1 = a1 <= b1; +>r3a1 : boolean +>a1 <= b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r3a2 = a2 <= b2; +>r3a2 : boolean +>a2 <= b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r3a3 = a3 <= b3; +>r3a3 : boolean +>a3 <= b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r3a4 = a4 <= b4; +>r3a4 : boolean +>a4 <= b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r3a5 = a5 <= b5; +>r3a5 : boolean +>a5 <= b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r3a6 = a6 <= b6; +>r3a6 : boolean +>a6 <= b6 : boolean +>a6 : new (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 (x: T) => T + +var r3b2 = b2 <= a2; +>r3b2 : boolean +>b2 <= a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r3b3 = b3 <= a3; +>r3b3 : boolean +>b3 <= a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r3b4 = b4 <= a4; +>r3b4 : boolean +>b4 <= a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r3b5 = b5 <= a5; +>r3b5 : boolean +>b5 <= a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r3b6 = b6 <= a6; +>r3b6 : boolean +>b6 <= a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r3b7 = b7 <= a7; + +// operator >= +var r4a1 = a1 >= b1; +>r4a1 : boolean +>a1 >= b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r4a2 = a2 >= b2; +>r4a2 : boolean +>a2 >= b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r4a3 = a3 >= b3; +>r4a3 : boolean +>a3 >= b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r4a4 = a4 >= b4; +>r4a4 : boolean +>a4 >= b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r4a5 = a5 >= b5; +>r4a5 : boolean +>a5 >= b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r4a6 = a6 >= b6; +>r4a6 : boolean +>a6 >= b6 : boolean +>a6 : new (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 (x: T) => T + +var r4b2 = b2 >= a2; +>r4b2 : boolean +>b2 >= a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r4b3 = b3 >= a3; +>r4b3 : boolean +>b3 >= a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r4b4 = b4 >= a4; +>r4b4 : boolean +>b4 >= a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r4b5 = b5 >= a5; +>r4b5 : boolean +>b5 >= a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r4b6 = b6 >= a6; +>r4b6 : boolean +>b6 >= a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r4b7 = b7 >= a7; + +// operator == +var r5a1 = a1 == b1; +>r5a1 : boolean +>a1 == b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r5a2 = a2 == b2; +>r5a2 : boolean +>a2 == b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r5a3 = a3 == b3; +>r5a3 : boolean +>a3 == b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r5a4 = a4 == b4; +>r5a4 : boolean +>a4 == b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r5a5 = a5 == b5; +>r5a5 : boolean +>a5 == b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r5a6 = a6 == b6; +>r5a6 : boolean +>a6 == b6 : boolean +>a6 : new (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 (x: T) => T + +var r5b2 = b2 == a2; +>r5b2 : boolean +>b2 == a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r5b3 = b3 == a3; +>r5b3 : boolean +>b3 == a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r5b4 = b4 == a4; +>r5b4 : boolean +>b4 == a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r5b5 = b5 == a5; +>r5b5 : boolean +>b5 == a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r5b6 = b6 == a6; +>r5b6 : boolean +>b6 == a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r5b7 = b7 == a7; + +// operator != +var r6a1 = a1 != b1; +>r6a1 : boolean +>a1 != b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r6a2 = a2 != b2; +>r6a2 : boolean +>a2 != b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r6a3 = a3 != b3; +>r6a3 : boolean +>a3 != b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r6a4 = a4 != b4; +>r6a4 : boolean +>a4 != b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r6a5 = a5 != b5; +>r6a5 : boolean +>a5 != b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r6a6 = a6 != b6; +>r6a6 : boolean +>a6 != b6 : boolean +>a6 : new (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 (x: T) => T + +var r6b2 = b2 != a2; +>r6b2 : boolean +>b2 != a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r6b3 = b3 != a3; +>r6b3 : boolean +>b3 != a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r6b4 = b4 != a4; +>r6b4 : boolean +>b4 != a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r6b5 = b5 != a5; +>r6b5 : boolean +>b5 != a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r6b6 = b6 != a6; +>r6b6 : boolean +>b6 != a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r6b7 = b7 != a7; + +// operator === +var r7a1 = a1 === b1; +>r7a1 : boolean +>a1 === b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r7a2 = a2 === b2; +>r7a2 : boolean +>a2 === b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r7a3 = a3 === b3; +>r7a3 : boolean +>a3 === b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r7a4 = a4 === b4; +>r7a4 : boolean +>a4 === b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r7a5 = a5 === b5; +>r7a5 : boolean +>a5 === b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r7a6 = a6 === b6; +>r7a6 : boolean +>a6 === b6 : boolean +>a6 : new (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 (x: T) => T + +var r7b2 = b2 === a2; +>r7b2 : boolean +>b2 === a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r7b3 = b3 === a3; +>r7b3 : boolean +>b3 === a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r7b4 = b4 === a4; +>r7b4 : boolean +>b4 === a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r7b5 = b5 === a5; +>r7b5 : boolean +>b5 === a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r7b6 = b6 === a6; +>r7b6 : boolean +>b6 === a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r7b7 = b7 === a7; + +// operator !== +var r8a1 = a1 !== b1; +>r8a1 : boolean +>a1 !== b1 : boolean +>a1 : new (x: T) => T +>b1 : new (x: string) => string + +var r8a2 = a2 !== b2; +>r8a2 : boolean +>a2 !== b2 : boolean +>a2 : new (x: T) => T +>b2 : new (x: string, y: number) => string + +var r8a3 = a3 !== b3; +>r8a3 : boolean +>a3 !== b3 : boolean +>a3 : new (x: T, y: U) => T +>b3 : new (x: string, y: number) => string + +var r8a4 = a4 !== b4; +>r8a4 : boolean +>a4 !== b4 : boolean +>a4 : new (x?: T) => T +>b4 : new (x?: string) => string + +var r8a5 = a5 !== b5; +>r8a5 : boolean +>a5 !== b5 : boolean +>a5 : new (...x: T[]) => T +>b5 : new (...x: string[]) => string + +var r8a6 = a6 !== b6; +>r8a6 : boolean +>a6 !== b6 : boolean +>a6 : new (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 (x: T) => T + +var r8b2 = b2 !== a2; +>r8b2 : boolean +>b2 !== a2 : boolean +>b2 : new (x: string, y: number) => string +>a2 : new (x: T) => T + +var r8b3 = b3 !== a3; +>r8b3 : boolean +>b3 !== a3 : boolean +>b3 : new (x: string, y: number) => string +>a3 : new (x: T, y: U) => T + +var r8b4 = b4 !== a4; +>r8b4 : boolean +>b4 !== a4 : boolean +>b4 : new (x?: string) => string +>a4 : new (x?: T) => T + +var r8b5 = b5 !== a5; +>r8b5 : boolean +>b5 !== a5 : boolean +>b5 : new (...x: string[]) => string +>a5 : new (...x: T[]) => T + +var r8b6 = b6 !== a6; +>r8b6 : boolean +>b6 !== a6 : boolean +>b6 : new (x: string, y: number) => {} +>a6 : new (x: T, y: T) => T + +//var r8b7 = b7 !== a7; diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt new file mode 100644 index 00000000000..2b14bd97bad --- /dev/null +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt @@ -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(x: T) { + if (true) { + return x; + } else { + return null; + } + } + + //function f7(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) => { } + } + } \ No newline at end of file diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.types b/tests/baselines/reference/functionWithMultipleReturnStatements2.types deleted file mode 100644 index 706aca40c94..00000000000 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.types +++ /dev/null @@ -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(x: T) { ->f6 : (x: T) => T ->T : T ->x : T ->T : T - - if (true) { - return x; ->x : T - - } else { - return null; - } -} - -//function f7(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 - } -} diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt b/tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt new file mode 100644 index 00000000000..43bad8f6a1d --- /dev/null +++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt @@ -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(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(x: T) { + var r6 = foo((a: T) => a, (b: T) => b); // T => T + var r6b = foo((a) => a, (b) => b); // {} => {} + } + + function other2(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(a: (x: T) => T, b: (x: T) => T) { + var r: (x: T) => T; + return r; + } + + function other3(x: T) { + var r8 = foo2((a: Date) => a, (b: Date) => b); // Date => Date + } \ No newline at end of file diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments.types deleted file mode 100644 index 9f634070b56..00000000000 --- a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types +++ /dev/null @@ -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(a: (x: T) => T, b: (x: T) => T) { ->foo : (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 : (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 : (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 : (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 : (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 : (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 : (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(x: T) { ->other : (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 : (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 : (a: (x: T) => T, b: (x: T) => T) => (x: T) => T ->(a) => a : (a: {}) => {} ->a : {} ->a : {} ->(b) => b : (b: {}) => {} ->b : {} ->b : {} -} - -function other2(x: T) { ->other2 : (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 : (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 : (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(a: (x: T) => T, b: (x: T) => T) { ->foo2 : (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(x: T) { ->other3 : (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 : (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 -} diff --git a/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt b/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt new file mode 100644 index 00000000000..c14db877073 --- /dev/null +++ b/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt @@ -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(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; \ No newline at end of file diff --git a/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types b/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types deleted file mode 100644 index e37a010baed..00000000000 --- a/tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types +++ /dev/null @@ -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(x: T, y: T) { ->foo : (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 : (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 : (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 : (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 : (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 : (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 : (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 : (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 : (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 : (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 : (x: T, y: T) => T ->s2 : (x: string) => string ->s1 : (x: Object) => string - diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types b/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types index f4bd9f447a8..055863e0bfa 100644 --- a/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types +++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types @@ -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; } diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types b/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types index 7ad4580090c..96204004b64 100644 --- a/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types +++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types @@ -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; } From 04dad2cc222492a41b878252a073840dbf795b79 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 20 Oct 2014 11:20:14 -0700 Subject: [PATCH 3/3] Adding missing blank --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e87d3d70a37..80116a6a168 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3357,7 +3357,7 @@ module ts { var sourceProp = getPropertyOfApparentType(source, targetProp.name); if (sourceProp !== targetProp) { if (!sourceProp) { - if (relation ===subtypeRelation || !isOptionalProperty(targetProp)) { + if (relation === subtypeRelation || !isOptionalProperty(targetProp)) { if (reportErrors) { reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source)); }