From c5b4051f3ae186fdcc723923a4846a86f5ccba8f Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Tue, 4 Nov 2014 13:33:43 -0800 Subject: [PATCH] Test cases for contextual typing of union type members --- .../contextualTypeWithUnionTypeMembers.js | 207 +++++++++ .../contextualTypeWithUnionTypeMembers.types | 438 ++++++++++++++++++ ...lTypeWithUnionTypeObjectLiteral.errors.txt | 130 ++++++ ...ontextualTypeWithUnionTypeObjectLiteral.js | 115 +++++ .../contextualTypeWithUnionTypeMembers.ts | 119 +++++ ...ontextualTypeWithUnionTypeObjectLiteral.ts | 59 +++ 6 files changed, 1068 insertions(+) create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeMembers.js create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeMembers.types create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.errors.txt create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.js create mode 100644 tests/cases/conformance/types/union/contextualTypeWithUnionTypeMembers.ts create mode 100644 tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.js b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.js new file mode 100644 index 00000000000..b04c804ad7e --- /dev/null +++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.js @@ -0,0 +1,207 @@ +//// [contextualTypeWithUnionTypeMembers.ts] +//When used as a contextual type, a union type U has those members that are present in any of +// its constituent types, with types that are unions of the respective members in the constituent types. +interface I1 { + commonMethodType(a: string): string; + commonPropertyType: string; + commonMethodWithTypeParameter(a: T): T; + + methodOnlyInI1(a: string): string; + propertyOnlyInI1: string; +} +interface I2 { + commonMethodType(a: string): string; + commonPropertyType: string; + commonMethodWithTypeParameter(a: T): T; + + methodOnlyInI2(a: string): string; + propertyOnlyInI2: string; +} + +// Let S be the set of types in U that has a property P. +// If S is not empty, U has a property P of a union type of the types of P from each type in S. +var i1: I1; +var i2: I2; +var i1Ori2: I1 | I2 = i1; +var i1Ori2: I1 | I2 = i2; +var i1Ori2: I1 | I2 = { // Like i1 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", +}; +var i1Ori2: I1 | I2 = { // Like i2 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", +}; +var i1Ori2: I1 | I2 = { // Like i1 and i2 both + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", +}; + +var arrayI1OrI2: Array | I2> = [i1, i2, { // Like i1 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + }, + { // Like i2 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", + }, { // Like i1 and i2 both + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", + }]; + +interface I11 { + commonMethodDifferentReturnType(a: string, b: number): string; + commonPropertyDifferentType: string; +} +interface I21 { + commonMethodDifferentReturnType(a: string, b: number): number; + commonPropertyDifferentType: number; +} +var i11: I11; +var i21: I21; +var i11Ori21: I11 | I21 = i11; +var i11Ori21: I11 | I21 = i21; +var i11Ori21: I11 | I21 = { + // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello", +}; +var i11Ori21: I11 | I21 = { + // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10, +}; +var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { + // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello", + }, { + // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10, + }]; + +//// [contextualTypeWithUnionTypeMembers.js] +// Let S be the set of types in U that has a property P. +// If S is not empty, U has a property P of a union type of the types of P from each type in S. +var i1; +var i2; +var i1Ori2 = i1; +var i1Ori2 = i2; +var i1Ori2 = { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI1: function (a) { return a; }, + propertyOnlyInI1: "Hello" +}; +var i1Ori2 = { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI2: function (a) { return a; }, + propertyOnlyInI2: "Hello" +}; +var i1Ori2 = { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI1: function (a) { return a; }, + propertyOnlyInI1: "Hello", + methodOnlyInI2: function (a) { return a; }, + propertyOnlyInI2: "Hello" +}; +var arrayI1OrI2 = [i1, i2, { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI1: function (a) { return a; }, + propertyOnlyInI1: "Hello" +}, { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI2: function (a) { return a; }, + propertyOnlyInI2: "Hello" +}, { + commonPropertyType: "hello", + commonMethodType: function (a) { return a; }, + commonMethodWithTypeParameter: function (a) { return a; }, + methodOnlyInI1: function (a) { return a; }, + propertyOnlyInI1: "Hello", + methodOnlyInI2: function (a) { return a; }, + propertyOnlyInI2: "Hello" +}]; +var i11; +var i21; +var i11Ori21 = i11; +var i11Ori21 = i21; +var i11Ori21 = { + // Like i1 + commonMethodDifferentReturnType: function (a, b) { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello" +}; +var i11Ori21 = { + // Like i2 + commonMethodDifferentReturnType: function (a, b) { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10 +}; +var arrayOrI11OrI21 = [i11, i21, i11 || i21, { + // Like i1 + commonMethodDifferentReturnType: function (a, b) { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello" +}, { + // Like i2 + commonMethodDifferentReturnType: function (a, b) { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10 +}]; diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.types b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.types new file mode 100644 index 00000000000..93e01910870 --- /dev/null +++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.types @@ -0,0 +1,438 @@ +=== tests/cases/conformance/types/union/contextualTypeWithUnionTypeMembers.ts === +//When used as a contextual type, a union type U has those members that are present in any of +// its constituent types, with types that are unions of the respective members in the constituent types. +interface I1 { +>I1 : I1 +>T : T + + commonMethodType(a: string): string; +>commonMethodType : (a: string) => string +>a : string + + commonPropertyType: string; +>commonPropertyType : string + + commonMethodWithTypeParameter(a: T): T; +>commonMethodWithTypeParameter : (a: T) => T +>a : T +>T : T +>T : T + + methodOnlyInI1(a: string): string; +>methodOnlyInI1 : (a: string) => string +>a : string + + propertyOnlyInI1: string; +>propertyOnlyInI1 : string +} +interface I2 { +>I2 : I2 +>T : T + + commonMethodType(a: string): string; +>commonMethodType : (a: string) => string +>a : string + + commonPropertyType: string; +>commonPropertyType : string + + commonMethodWithTypeParameter(a: T): T; +>commonMethodWithTypeParameter : (a: T) => T +>a : T +>T : T +>T : T + + methodOnlyInI2(a: string): string; +>methodOnlyInI2 : (a: string) => string +>a : string + + propertyOnlyInI2: string; +>propertyOnlyInI2 : string +} + +// Let S be the set of types in U that has a property P. +// If S is not empty, U has a property P of a union type of the types of P from each type in S. +var i1: I1; +>i1 : I1 +>I1 : I1 + +var i2: I2; +>i2 : I2 +>I2 : I2 + +var i1Ori2: I1 | I2 = i1; +>i1Ori2 : I1 | I2 +>I1 : I1 +>I2 : I2 +>i1 : I1 + +var i1Ori2: I1 | I2 = i2; +>i1Ori2 : I1 | I2 +>I1 : I1 +>I2 : I2 +>i2 : I2 + +var i1Ori2: I1 | I2 = { // Like i1 +>i1Ori2 : I1 | I2 +>I1 : I1 +>I2 : I2 +>{ // Like i1 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello",} : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI1: a => a, +>methodOnlyInI1 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI1: "Hello", +>propertyOnlyInI1 : string + +}; +var i1Ori2: I1 | I2 = { // Like i2 +>i1Ori2 : I1 | I2 +>I1 : I1 +>I2 : I2 +>{ // Like i2 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI2: a => a, propertyOnlyInI2: "Hello",} : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI2: (a: string) => string; propertyOnlyInI2: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI2: a => a, +>methodOnlyInI2 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI2: "Hello", +>propertyOnlyInI2 : string + +}; +var i1Ori2: I1 | I2 = { // Like i1 and i2 both +>i1Ori2 : I1 | I2 +>I1 : I1 +>I2 : I2 +>{ // Like i1 and i2 both commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello", methodOnlyInI2: a => a, propertyOnlyInI2: "Hello",} : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; methodOnlyInI2: (a: string) => string; propertyOnlyInI2: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI1: a => a, +>methodOnlyInI1 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI1: "Hello", +>propertyOnlyInI1 : string + + methodOnlyInI2: a => a, +>methodOnlyInI2 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI2: "Hello", +>propertyOnlyInI2 : string + +}; + +var arrayI1OrI2: Array | I2> = [i1, i2, { // Like i1 +>arrayI1OrI2 : (I1 | I2)[] +>Array : T[] +>I1 : I1 +>I2 : I2 +>[i1, i2, { // Like i1 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello", }, { // Like i2 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI2: a => a, propertyOnlyInI2: "Hello", }, { // Like i1 and i2 both commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello", methodOnlyInI2: a => a, propertyOnlyInI2: "Hello", }] : (I1 | I2)[] +>i1 : I1 +>i2 : I2 +>{ // Like i1 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello", } : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI1: a => a, +>methodOnlyInI1 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI1: "Hello", +>propertyOnlyInI1 : string + + }, + { // Like i2 +>{ // Like i2 commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI2: a => a, propertyOnlyInI2: "Hello", } : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI2: (a: string) => string; propertyOnlyInI2: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI2: a => a, +>methodOnlyInI2 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI2: "Hello", +>propertyOnlyInI2 : string + + }, { // Like i1 and i2 both +>{ // Like i1 and i2 both commonPropertyType: "hello", commonMethodType: a=> a, commonMethodWithTypeParameter: a => a, methodOnlyInI1: a => a, propertyOnlyInI1: "Hello", methodOnlyInI2: a => a, propertyOnlyInI2: "Hello", } : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; methodOnlyInI2: (a: string) => string; propertyOnlyInI2: string; } + + commonPropertyType: "hello", +>commonPropertyType : string + + commonMethodType: a=> a, +>commonMethodType : (a: string) => string +>a=> a : (a: string) => string +>a : string +>a : string + + commonMethodWithTypeParameter: a => a, +>commonMethodWithTypeParameter : (a: number) => number +>a => a : (a: number) => number +>a : number +>a : number + + methodOnlyInI1: a => a, +>methodOnlyInI1 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI1: "Hello", +>propertyOnlyInI1 : string + + methodOnlyInI2: a => a, +>methodOnlyInI2 : (a: string) => string +>a => a : (a: string) => string +>a : string +>a : string + + propertyOnlyInI2: "Hello", +>propertyOnlyInI2 : string + + }]; + +interface I11 { +>I11 : I11 + + commonMethodDifferentReturnType(a: string, b: number): string; +>commonMethodDifferentReturnType : (a: string, b: number) => string +>a : string +>b : number + + commonPropertyDifferentType: string; +>commonPropertyDifferentType : string +} +interface I21 { +>I21 : I21 + + commonMethodDifferentReturnType(a: string, b: number): number; +>commonMethodDifferentReturnType : (a: string, b: number) => number +>a : string +>b : number + + commonPropertyDifferentType: number; +>commonPropertyDifferentType : number +} +var i11: I11; +>i11 : I11 +>I11 : I11 + +var i21: I21; +>i21 : I21 +>I21 : I21 + +var i11Ori21: I11 | I21 = i11; +>i11Ori21 : I11 | I21 +>I11 : I11 +>I21 : I21 +>i11 : I11 + +var i11Ori21: I11 | I21 = i21; +>i11Ori21 : I11 | I21 +>I11 : I11 +>I21 : I21 +>i21 : I21 + +var i11Ori21: I11 | I21 = { +>i11Ori21 : I11 | I21 +>I11 : I11 +>I21 : I21 +>{ // Like i1 commonMethodDifferentReturnType: (a, b) => { var z = a.charAt(b); return z; }, commonPropertyDifferentType: "hello", } : { commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: string; } + + // Like i1 + commonMethodDifferentReturnType: (a, b) => { +>commonMethodDifferentReturnType : (a: any, b: any) => any +>(a, b) => { var z = a.charAt(b); return z; } : (a: any, b: any) => any +>a : any +>b : any + + var z = a.charAt(b); +>z : any +>a.charAt(b) : any +>a.charAt : any +>a : any +>charAt : any +>b : any + + return z; +>z : any + + }, + commonPropertyDifferentType: "hello", +>commonPropertyDifferentType : string + +}; +var i11Ori21: I11 | I21 = { +>i11Ori21 : I11 | I21 +>I11 : I11 +>I21 : I21 +>{ // Like i2 commonMethodDifferentReturnType: (a, b) => { var z = a.charCodeAt(b); return z; }, commonPropertyDifferentType: 10,} : { commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: number; } + + // Like i2 + commonMethodDifferentReturnType: (a, b) => { +>commonMethodDifferentReturnType : (a: any, b: any) => any +>(a, b) => { var z = a.charCodeAt(b); return z; } : (a: any, b: any) => any +>a : any +>b : any + + var z = a.charCodeAt(b); +>z : any +>a.charCodeAt(b) : any +>a.charCodeAt : any +>a : any +>charCodeAt : any +>b : any + + return z; +>z : any + + }, + commonPropertyDifferentType: 10, +>commonPropertyDifferentType : number + +}; +var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { +>arrayOrI11OrI21 : (I11 | I21)[] +>Array : T[] +>I11 : I11 +>I21 : I21 +>[i11, i21, i11 || i21, { // Like i1 commonMethodDifferentReturnType: (a, b) => { var z = a.charAt(b); return z; }, commonPropertyDifferentType: "hello", }, { // Like i2 commonMethodDifferentReturnType: (a, b) => { var z = a.charCodeAt(b); return z; }, commonPropertyDifferentType: 10, }] : ({ commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: string; } | { commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: number; })[] +>i11 : I11 +>i21 : I21 +>i11 || i21 : I11 | I21 +>i11 : I11 +>i21 : I21 +>{ // Like i1 commonMethodDifferentReturnType: (a, b) => { var z = a.charAt(b); return z; }, commonPropertyDifferentType: "hello", } : { commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: string; } + + // Like i1 + commonMethodDifferentReturnType: (a, b) => { +>commonMethodDifferentReturnType : (a: any, b: any) => any +>(a, b) => { var z = a.charAt(b); return z; } : (a: any, b: any) => any +>a : any +>b : any + + var z = a.charAt(b); +>z : any +>a.charAt(b) : any +>a.charAt : any +>a : any +>charAt : any +>b : any + + return z; +>z : any + + }, + commonPropertyDifferentType: "hello", +>commonPropertyDifferentType : string + + }, { +>{ // Like i2 commonMethodDifferentReturnType: (a, b) => { var z = a.charCodeAt(b); return z; }, commonPropertyDifferentType: 10, } : { commonMethodDifferentReturnType: (a: any, b: any) => any; commonPropertyDifferentType: number; } + + // Like i2 + commonMethodDifferentReturnType: (a, b) => { +>commonMethodDifferentReturnType : (a: any, b: any) => any +>(a, b) => { var z = a.charCodeAt(b); return z; } : (a: any, b: any) => any +>a : any +>b : any + + var z = a.charCodeAt(b); +>z : any +>a.charCodeAt(b) : any +>a.charCodeAt : any +>a : any +>charCodeAt : any +>b : any + + return z; +>z : any + + }, + commonPropertyDifferentType: 10, +>commonPropertyDifferentType : number + + }]; diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.errors.txt b/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.errors.txt new file mode 100644 index 00000000000..9ef73eaf337 --- /dev/null +++ b/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.errors.txt @@ -0,0 +1,130 @@ +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(14,5): error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: string; } | { prop: number; }'. + Type '{ prop: string | number; }' is not assignable to type '{ prop: number; }'. + Types of property 'prop' are incompatible. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(20,5): error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; }'. + Type '{ prop: string | number; }' is not assignable to type '{ prop: number; }'. + Types of property 'prop' are incompatible. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(21,5): error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; }'. + Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: number; }'. + Types of property 'prop' are incompatible. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(25,5): error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; anotherP1: number; }'. + Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: number; anotherP1: number; }'. + Types of property 'prop' are incompatible. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(29,5): error TS2323: Type '{ prop: string | number; anotherP: string; anotherP1: number; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; anotherP1: number; }'. + Type '{ prop: string | number; anotherP: string; anotherP1: number; }' is not assignable to type '{ prop: number; anotherP1: number; }'. + Types of property 'prop' are incompatible. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts(57,5): error TS2323: Type '{ commonMethodDifferentReturnType: (a: any, b: any) => string | number; }' is not assignable to type 'I11 | I21'. + Type '{ commonMethodDifferentReturnType: (a: any, b: any) => string | number; }' is not assignable to type 'I21'. + Types of property 'commonMethodDifferentReturnType' are incompatible. + Type '(a: any, b: any) => string | number' is not assignable to type '(a: string, b: number) => number'. + Type 'string | number' is not assignable to type 'number'. + Type 'string' is not assignable to type 'number'. + + +==== tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts (6 errors) ==== + var str: string; + var num: number; + var strOrNumber: string | number = str || num; + var objStr: { prop: string }; + var objNum: { prop: number }; + var objStrOrNum1: { prop: string } | { prop: number } = objStr || objNum; + var objStrOrNum2: { prop: string | number } = objStr || objNum; + // Below is error because : + // Spec says: + // S is a union type and each constituent type of S is assignable to T. + // T is a union type and S is assignable to at least one constituent type of T. + // In case of objStrOrNum3, the S is not union Type but object Literal so we go to next step. + // Since T is union Type we only allow the assignment of either object with property of type string or object with property of type number but do not allow object with property of type string | number + var objStrOrNum3: { prop: string } | { prop: number } = { + ~~~~~~~~~~~~ +!!! error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: string; } | { prop: number; }'. +!!! error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: number; }'. +!!! error TS2323: Types of property 'prop' are incompatible. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + prop: strOrNumber + }; + var objStrOrNum4: { prop: string | number } = { + prop: strOrNumber + }; + var objStrOrNum5: { prop: string; anotherP: string; } | { prop: number } = { prop: strOrNumber }; + ~~~~~~~~~~~~ +!!! error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; }'. +!!! error TS2323: Type '{ prop: string | number; }' is not assignable to type '{ prop: number; }'. +!!! error TS2323: Types of property 'prop' are incompatible. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + var objStrOrNum6: { prop: string; anotherP: string; } | { prop: number } = { + ~~~~~~~~~~~~ +!!! error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; }'. +!!! error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: number; }'. +!!! error TS2323: Types of property 'prop' are incompatible. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + prop: strOrNumber, + anotherP: str + }; + var objStrOrNum7: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + ~~~~~~~~~~~~ +!!! error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; anotherP1: number; }'. +!!! error TS2323: Type '{ prop: string | number; anotherP: string; }' is not assignable to type '{ prop: number; anotherP1: number; }'. +!!! error TS2323: Types of property 'prop' are incompatible. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + prop: strOrNumber, + anotherP: str + }; + var objStrOrNum8: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + ~~~~~~~~~~~~ +!!! error TS2323: Type '{ prop: string | number; anotherP: string; anotherP1: number; }' is not assignable to type '{ prop: string; anotherP: string; } | { prop: number; anotherP1: number; }'. +!!! error TS2323: Type '{ prop: string | number; anotherP: string; anotherP1: number; }' is not assignable to type '{ prop: number; anotherP1: number; }'. +!!! error TS2323: Types of property 'prop' are incompatible. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + prop: strOrNumber, + anotherP: str, + anotherP1: num + }; + interface I11 { + commonMethodDifferentReturnType(a: string, b: number): string; + } + interface I21 { + commonMethodDifferentReturnType(a: string, b: number): number; + } + var i11: I11; + var i21: I21; + var i11Ori21: I11 | I21 = i11; + var i11Ori21: I11 | I21 = i21; + var i11Ori21: I11 | I21 = { // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, + }; + var i11Ori21: I11 | I21 = { // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, + }; + var strOrNumber: string | number; + var i11Ori21: I11 | I21 = { // Like i1 and i2 both + ~~~~~~~~ +!!! error TS2323: Type '{ commonMethodDifferentReturnType: (a: any, b: any) => string | number; }' is not assignable to type 'I11 | I21'. +!!! error TS2323: Type '{ commonMethodDifferentReturnType: (a: any, b: any) => string | number; }' is not assignable to type 'I21'. +!!! error TS2323: Types of property 'commonMethodDifferentReturnType' are incompatible. +!!! error TS2323: Type '(a: any, b: any) => string | number' is not assignable to type '(a: string, b: number) => number'. +!!! error TS2323: Type 'string | number' is not assignable to type 'number'. +!!! error TS2323: Type 'string' is not assignable to type 'number'. + commonMethodDifferentReturnType: (a, b) => strOrNumber, + }; \ No newline at end of file diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.js b/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.js new file mode 100644 index 00000000000..dc8f07823b6 --- /dev/null +++ b/tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.js @@ -0,0 +1,115 @@ +//// [contextualTypeWithUnionTypeObjectLiteral.ts] +var str: string; +var num: number; +var strOrNumber: string | number = str || num; +var objStr: { prop: string }; +var objNum: { prop: number }; +var objStrOrNum1: { prop: string } | { prop: number } = objStr || objNum; +var objStrOrNum2: { prop: string | number } = objStr || objNum; +// Below is error because : +// Spec says: +// S is a union type and each constituent type of S is assignable to T. +// T is a union type and S is assignable to at least one constituent type of T. +// In case of objStrOrNum3, the S is not union Type but object Literal so we go to next step. +// Since T is union Type we only allow the assignment of either object with property of type string or object with property of type number but do not allow object with property of type string | number +var objStrOrNum3: { prop: string } | { prop: number } = { + prop: strOrNumber +}; +var objStrOrNum4: { prop: string | number } = { + prop: strOrNumber +}; +var objStrOrNum5: { prop: string; anotherP: string; } | { prop: number } = { prop: strOrNumber }; +var objStrOrNum6: { prop: string; anotherP: string; } | { prop: number } = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum7: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum8: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + prop: strOrNumber, + anotherP: str, + anotherP1: num +}; +interface I11 { + commonMethodDifferentReturnType(a: string, b: number): string; +} +interface I21 { + commonMethodDifferentReturnType(a: string, b: number): number; +} +var i11: I11; +var i21: I21; +var i11Ori21: I11 | I21 = i11; +var i11Ori21: I11 | I21 = i21; +var i11Ori21: I11 | I21 = { // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, +}; +var i11Ori21: I11 | I21 = { // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, +}; +var strOrNumber: string | number; +var i11Ori21: I11 | I21 = { // Like i1 and i2 both + commonMethodDifferentReturnType: (a, b) => strOrNumber, +}; + +//// [contextualTypeWithUnionTypeObjectLiteral.js] +var str; +var num; +var strOrNumber = str || num; +var objStr; +var objNum; +var objStrOrNum1 = objStr || objNum; +var objStrOrNum2 = objStr || objNum; +// Below is error because : +// Spec says: +// S is a union type and each constituent type of S is assignable to T. +// T is a union type and S is assignable to at least one constituent type of T. +// In case of objStrOrNum3, the S is not union Type but object Literal so we go to next step. +// Since T is union Type we only allow the assignment of either object with property of type string or object with property of type number but do not allow object with property of type string | number +var objStrOrNum3 = { + prop: strOrNumber +}; +var objStrOrNum4 = { + prop: strOrNumber +}; +var objStrOrNum5 = { prop: strOrNumber }; +var objStrOrNum6 = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum7 = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum8 = { + prop: strOrNumber, + anotherP: str, + anotherP1: num +}; +var i11; +var i21; +var i11Ori21 = i11; +var i11Ori21 = i21; +var i11Ori21 = { + commonMethodDifferentReturnType: function (a, b) { + var z = a.charAt(b); + return z; + } +}; +var i11Ori21 = { + commonMethodDifferentReturnType: function (a, b) { + var z = a.charCodeAt(b); + return z; + } +}; +var strOrNumber; +var i11Ori21 = { + commonMethodDifferentReturnType: function (a, b) { return strOrNumber; } +}; diff --git a/tests/cases/conformance/types/union/contextualTypeWithUnionTypeMembers.ts b/tests/cases/conformance/types/union/contextualTypeWithUnionTypeMembers.ts new file mode 100644 index 00000000000..4799fb5e04b --- /dev/null +++ b/tests/cases/conformance/types/union/contextualTypeWithUnionTypeMembers.ts @@ -0,0 +1,119 @@ +//When used as a contextual type, a union type U has those members that are present in any of +// its constituent types, with types that are unions of the respective members in the constituent types. +interface I1 { + commonMethodType(a: string): string; + commonPropertyType: string; + commonMethodWithTypeParameter(a: T): T; + + methodOnlyInI1(a: string): string; + propertyOnlyInI1: string; +} +interface I2 { + commonMethodType(a: string): string; + commonPropertyType: string; + commonMethodWithTypeParameter(a: T): T; + + methodOnlyInI2(a: string): string; + propertyOnlyInI2: string; +} + +// Let S be the set of types in U that has a property P. +// If S is not empty, U has a property P of a union type of the types of P from each type in S. +var i1: I1; +var i2: I2; +var i1Ori2: I1 | I2 = i1; +var i1Ori2: I1 | I2 = i2; +var i1Ori2: I1 | I2 = { // Like i1 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", +}; +var i1Ori2: I1 | I2 = { // Like i2 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", +}; +var i1Ori2: I1 | I2 = { // Like i1 and i2 both + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", +}; + +var arrayI1OrI2: Array | I2> = [i1, i2, { // Like i1 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + }, + { // Like i2 + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", + }, { // Like i1 and i2 both + commonPropertyType: "hello", + commonMethodType: a=> a, + commonMethodWithTypeParameter: a => a, + methodOnlyInI1: a => a, + propertyOnlyInI1: "Hello", + methodOnlyInI2: a => a, + propertyOnlyInI2: "Hello", + }]; + +interface I11 { + commonMethodDifferentReturnType(a: string, b: number): string; + commonPropertyDifferentType: string; +} +interface I21 { + commonMethodDifferentReturnType(a: string, b: number): number; + commonPropertyDifferentType: number; +} +var i11: I11; +var i21: I21; +var i11Ori21: I11 | I21 = i11; +var i11Ori21: I11 | I21 = i21; +var i11Ori21: I11 | I21 = { + // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello", +}; +var i11Ori21: I11 | I21 = { + // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10, +}; +var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { + // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, + commonPropertyDifferentType: "hello", + }, { + // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, + commonPropertyDifferentType: 10, + }]; \ No newline at end of file diff --git a/tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts b/tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts new file mode 100644 index 00000000000..b6b328a5d09 --- /dev/null +++ b/tests/cases/conformance/types/union/contextualTypeWithUnionTypeObjectLiteral.ts @@ -0,0 +1,59 @@ +var str: string; +var num: number; +var strOrNumber: string | number = str || num; +var objStr: { prop: string }; +var objNum: { prop: number }; +var objStrOrNum1: { prop: string } | { prop: number } = objStr || objNum; +var objStrOrNum2: { prop: string | number } = objStr || objNum; +// Below is error because : +// Spec says: +// S is a union type and each constituent type of S is assignable to T. +// T is a union type and S is assignable to at least one constituent type of T. +// In case of objStrOrNum3, the S is not union Type but object Literal so we go to next step. +// Since T is union Type we only allow the assignment of either object with property of type string or object with property of type number but do not allow object with property of type string | number +var objStrOrNum3: { prop: string } | { prop: number } = { + prop: strOrNumber +}; +var objStrOrNum4: { prop: string | number } = { + prop: strOrNumber +}; +var objStrOrNum5: { prop: string; anotherP: string; } | { prop: number } = { prop: strOrNumber }; +var objStrOrNum6: { prop: string; anotherP: string; } | { prop: number } = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum7: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + prop: strOrNumber, + anotherP: str +}; +var objStrOrNum8: { prop: string; anotherP: string; } | { prop: number; anotherP1: number } = { + prop: strOrNumber, + anotherP: str, + anotherP1: num +}; +interface I11 { + commonMethodDifferentReturnType(a: string, b: number): string; +} +interface I21 { + commonMethodDifferentReturnType(a: string, b: number): number; +} +var i11: I11; +var i21: I21; +var i11Ori21: I11 | I21 = i11; +var i11Ori21: I11 | I21 = i21; +var i11Ori21: I11 | I21 = { // Like i1 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charAt(b); + return z; + }, +}; +var i11Ori21: I11 | I21 = { // Like i2 + commonMethodDifferentReturnType: (a, b) => { + var z = a.charCodeAt(b); + return z; + }, +}; +var strOrNumber: string | number; +var i11Ori21: I11 | I21 = { // Like i1 and i2 both + commonMethodDifferentReturnType: (a, b) => strOrNumber, +}; \ No newline at end of file