From fe7d056724a3b4688509414aa62b1f8123303b12 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sat, 1 Nov 2014 23:54:55 -0700 Subject: [PATCH 1/4] initial version of spec conformance tests for type aliases --- ...ectDependenceBetweenTypeAliases.errors.txt | 72 +++++++++++++++++++ .../directDependenceBetweenTypeAliases.js | 60 ++++++++++++++++ .../reservedNamesInAliases.errors.txt | 18 +++++ tests/baselines/reference/typeAliases.js | 30 ++++++++ tests/baselines/reference/typeAliases.types | 57 +++++++++++++++ .../typeAliasesForObjectTypes.errors.txt | 39 ++++++++++ .../directDependenceBetweenTypeAliases.ts | 41 +++++++++++ .../typeAliases/reservedNamesInAliases.ts | 6 ++ .../types/typeAliases/typeAliases.ts | 17 +++++ .../typeAliases/typeAliasesForObjectTypes.ts | 14 ++++ 10 files changed, 354 insertions(+) create mode 100644 tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt create mode 100644 tests/baselines/reference/directDependenceBetweenTypeAliases.js create mode 100644 tests/baselines/reference/reservedNamesInAliases.errors.txt create mode 100644 tests/baselines/reference/typeAliases.js create mode 100644 tests/baselines/reference/typeAliases.types create mode 100644 tests/baselines/reference/typeAliasesForObjectTypes.errors.txt create mode 100644 tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts create mode 100644 tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts create mode 100644 tests/cases/conformance/types/typeAliases/typeAliases.ts create mode 100644 tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt new file mode 100644 index 00000000000..2d269f7744b --- /dev/null +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt @@ -0,0 +1,72 @@ +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(4,6): error TS2456: Type alias 'T0' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(6,6): error TS2456: Type alias 'T0_2' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(11,6): error TS2456: Type alias 'T1' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(14,6): error TS2456: Type alias 'T2' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(16,6): error TS2456: Type alias 'T2_1' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(19,6): error TS2456: Type alias 'T3' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(22,6): error TS2456: Type alias 'T4' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(26,6): error TS2456: Type alias 'T5' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(30,6): error TS2456: Type alias 'T7' circularly references itself. + + +==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (9 errors) ==== + // It is an error for the type specified in a type alias to depend on that type alias + + // A type alias directly depends on the type it aliases. + type T0 = T0 + ~~ +!!! error TS2456: Type alias 'T0' circularly references itself. + type T0_1 = T0_2 + type T0_2 = T0_3 + ~~~~ +!!! error TS2456: Type alias 'T0_2' circularly references itself. + type T0_3 = T0_1 + + // A type reference directly depends on the referenced type and each of the type arguments, if any. + interface I {} + type T1 = I + ~~ +!!! error TS2456: Type alias 'T1' circularly references itself. + + // A union type directly depends on each of the constituent types. + type T2 = T2 | string + ~~ +!!! error TS2456: Type alias 'T2' circularly references itself. + class C {} + type T2_1 = T2_1[] | number + ~~~~ +!!! error TS2456: Type alias 'T2_1' circularly references itself. + + // An array type directly depends on its element type. + type T3 = T3[] + ~~ +!!! error TS2456: Type alias 'T3' circularly references itself. + + // A tuple type directly depends on each of its element types. + type T4 = [number, T4] + ~~ +!!! error TS2456: Type alias 'T4' circularly references itself. + + // A type query directly depends on the type of the referenced entity. + var x: T5[] = [] + type T5 = typeof x + ~~ +!!! error TS2456: Type alias 'T5' circularly references itself. + + class C1 {} + type T6 = T7 | number + type T7 = typeof yy + ~~ +!!! error TS2456: Type alias 'T7' circularly references itself. + var yy: [string, T8[]]; + type T8 = C + + // legal cases + type T9 = () => T9 + type T10 = { x: T10 } | { new(v: T10): string } + type T11 = T12[] + type T12 = [T13, string] + type T13 = typeof zz + var zz: { x: T10 } + + \ No newline at end of file diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.js b/tests/baselines/reference/directDependenceBetweenTypeAliases.js new file mode 100644 index 00000000000..cfa8b9e532b --- /dev/null +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.js @@ -0,0 +1,60 @@ +//// [directDependenceBetweenTypeAliases.ts] +// It is an error for the type specified in a type alias to depend on that type alias + +// A type alias directly depends on the type it aliases. +type T0 = T0 +type T0_1 = T0_2 +type T0_2 = T0_3 +type T0_3 = T0_1 + +// A type reference directly depends on the referenced type and each of the type arguments, if any. +interface I {} +type T1 = I + +// A union type directly depends on each of the constituent types. +type T2 = T2 | string +class C {} +type T2_1 = T2_1[] | number + +// An array type directly depends on its element type. +type T3 = T3[] + +// A tuple type directly depends on each of its element types. +type T4 = [number, T4] + +// A type query directly depends on the type of the referenced entity. +var x: T5[] = [] +type T5 = typeof x + +class C1 {} +type T6 = T7 | number +type T7 = typeof yy +var yy: [string, T8[]]; +type T8 = C + +// legal cases +type T9 = () => T9 +type T10 = { x: T10 } | { new(v: T10): string } +type T11 = T12[] +type T12 = [T13, string] +type T13 = typeof zz +var zz: { x: T10 } + + + +//// [directDependenceBetweenTypeAliases.js] +// It is an error for the type specified in a type alias to depend on that type alias +var C = (function () { + function C() { + } + return C; +})(); +// A type query directly depends on the type of the referenced entity. +var x = []; +var C1 = (function () { + function C1() { + } + return C1; +})(); +var yy; +var zz; diff --git a/tests/baselines/reference/reservedNamesInAliases.errors.txt b/tests/baselines/reference/reservedNamesInAliases.errors.txt new file mode 100644 index 00000000000..758c77a76f3 --- /dev/null +++ b/tests/baselines/reference/reservedNamesInAliases.errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,6): error TS1003: Identifier expected. +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,11): error TS1005: ';' expected. +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,13): error TS2304: Cannot find name 'I'. + + +==== tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts (3 errors) ==== + interface I {} + type any = I; + type number = I; + type boolean = I; + type string = I; + type void = I; + ~~~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1005: ';' expected. + ~ +!!! error TS2304: Cannot find name 'I'. \ No newline at end of file diff --git a/tests/baselines/reference/typeAliases.js b/tests/baselines/reference/typeAliases.js new file mode 100644 index 00000000000..6a43fc8b701 --- /dev/null +++ b/tests/baselines/reference/typeAliases.js @@ -0,0 +1,30 @@ +//// [typeAliases.ts] +// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. + +type Meters = number + +enum E { x = 10 } + +declare function f(a: string): boolean; +declare function f(a: Meters): string; +f(E.x).toLowerCase(); + +type StringAndBoolean = [string, boolean] +declare function f1(s: StringAndBoolean): string; +var x: [string, boolean]; +f1(x); + +var y: StringAndBoolean = ["1", false]; +y[0].toLowerCase(); + +//// [typeAliases.js] +// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. +var E; +(function (E) { + E[E["x"] = 10] = "x"; +})(E || (E = {})); +f(10 /* x */).toLowerCase(); +var x; +f1(x); +var y = ["1", false]; +y[0].toLowerCase(); diff --git a/tests/baselines/reference/typeAliases.types b/tests/baselines/reference/typeAliases.types new file mode 100644 index 00000000000..c91d39c5805 --- /dev/null +++ b/tests/baselines/reference/typeAliases.types @@ -0,0 +1,57 @@ +=== tests/cases/conformance/types/typeAliases/typeAliases.ts === +// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. + +type Meters = number +>Meters : number + +enum E { x = 10 } +>E : E +>x : E + +declare function f(a: string): boolean; +>f : { (a: string): boolean; (a: number): string; } +>a : string + +declare function f(a: Meters): string; +>f : { (a: string): boolean; (a: number): string; } +>a : number +>Meters : number + +f(E.x).toLowerCase(); +>f(E.x).toLowerCase() : string +>f(E.x).toLowerCase : () => string +>f(E.x) : string +>f : { (a: string): boolean; (a: number): string; } +>E.x : E +>E : typeof E +>x : E +>toLowerCase : () => string + +type StringAndBoolean = [string, boolean] +>StringAndBoolean : [string, boolean] + +declare function f1(s: StringAndBoolean): string; +>f1 : (s: [string, boolean]) => string +>s : [string, boolean] +>StringAndBoolean : [string, boolean] + +var x: [string, boolean]; +>x : [string, boolean] + +f1(x); +>f1(x) : string +>f1 : (s: [string, boolean]) => string +>x : [string, boolean] + +var y: StringAndBoolean = ["1", false]; +>y : [string, boolean] +>StringAndBoolean : [string, boolean] +>["1", false] : [string, boolean] + +y[0].toLowerCase(); +>y[0].toLowerCase() : string +>y[0].toLowerCase : () => string +>y[0] : string +>y : [string, boolean] +>toLowerCase : () => string + diff --git a/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt b/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt new file mode 100644 index 00000000000..d957b589953 --- /dev/null +++ b/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(14,8): error TS1005: '=' expected. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(14,12): error TS1005: '(' expected. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(4,22): error TS2312: An interface may only extend a class or another interface. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(5,21): error TS2422: A class may only implement another class or interface. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(10,6): error TS2300: Duplicate identifier 'T2'. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(11,6): error TS2300: Duplicate identifier 'T2'. +tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(14,19): error TS2304: Cannot find name 'T'. + + +==== tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts (7 errors) ==== + type T1 = { x: string } + + // An interface can be named in an extends or implements clause, but a type alias for an object type literal cannot. + interface I1 extends T1 { y: string } + ~~ +!!! error TS2312: An interface may only extend a class or another interface. + class C1 implements T1 { + ~~ +!!! error TS2422: A class may only implement another class or interface. + x: string; + } + + // An interface can have multiple merged declarations, but a type alias for an object type literal cannot. + type T2 = { x: string } + ~~ +!!! error TS2300: Duplicate identifier 'T2'. + type T2 = { y: number } + ~~ +!!! error TS2300: Duplicate identifier 'T2'. + + // An interface can have type parameters, but a type alias for an object type literal cannot. + type T3 = { x: T } + ~ +!!! error TS1005: '=' expected. + ~ +!!! error TS1005: '(' expected. + ~ +!!! error TS2304: Cannot find name 'T'. + \ No newline at end of file diff --git a/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts b/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts new file mode 100644 index 00000000000..16aafec627d --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts @@ -0,0 +1,41 @@ +// It is an error for the type specified in a type alias to depend on that type alias + +// A type alias directly depends on the type it aliases. +type T0 = T0 +type T0_1 = T0_2 +type T0_2 = T0_3 +type T0_3 = T0_1 + +// A type reference directly depends on the referenced type and each of the type arguments, if any. +interface I {} +type T1 = I + +// A union type directly depends on each of the constituent types. +type T2 = T2 | string +class C {} +type T2_1 = T2_1[] | number + +// An array type directly depends on its element type. +type T3 = T3[] + +// A tuple type directly depends on each of its element types. +type T4 = [number, T4] + +// A type query directly depends on the type of the referenced entity. +var x: T5[] = [] +type T5 = typeof x + +class C1 {} +type T6 = T7 | number +type T7 = typeof yy +var yy: [string, T8[]]; +type T8 = C + +// legal cases +type T9 = () => T9 +type T10 = { x: T10 } | { new(v: T10): string } +type T11 = T12[] +type T12 = [T13, string] +type T13 = typeof zz +var zz: { x: T10 } + diff --git a/tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts b/tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts new file mode 100644 index 00000000000..3b115573830 --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts @@ -0,0 +1,6 @@ +interface I {} +type any = I; +type number = I; +type boolean = I; +type string = I; +type void = I; \ No newline at end of file diff --git a/tests/cases/conformance/types/typeAliases/typeAliases.ts b/tests/cases/conformance/types/typeAliases/typeAliases.ts new file mode 100644 index 00000000000..72cbcb7a4a6 --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/typeAliases.ts @@ -0,0 +1,17 @@ +// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. + +type Meters = number + +enum E { x = 10 } + +declare function f(a: string): boolean; +declare function f(a: Meters): string; +f(E.x).toLowerCase(); + +type StringAndBoolean = [string, boolean] +declare function f1(s: StringAndBoolean): string; +var x: [string, boolean]; +f1(x); + +var y: StringAndBoolean = ["1", false]; +y[0].toLowerCase(); \ No newline at end of file diff --git a/tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts b/tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts new file mode 100644 index 00000000000..f1fd2a58bac --- /dev/null +++ b/tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts @@ -0,0 +1,14 @@ +type T1 = { x: string } + +// An interface can be named in an extends or implements clause, but a type alias for an object type literal cannot. +interface I1 extends T1 { y: string } +class C1 implements T1 { + x: string; +} + +// An interface can have multiple merged declarations, but a type alias for an object type literal cannot. +type T2 = { x: string } +type T2 = { y: number } + +// An interface can have type parameters, but a type alias for an object type literal cannot. +type T3 = { x: T } From d86d520c3309563b83eb3996111470b8ddea2343 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sun, 2 Nov 2014 12:31:44 -0800 Subject: [PATCH 2/4] merge with master --- .../reference/reservedNamesInAliases.errors.txt | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/tests/baselines/reference/reservedNamesInAliases.errors.txt b/tests/baselines/reference/reservedNamesInAliases.errors.txt index 758c77a76f3..9f2d87c5409 100644 --- a/tests/baselines/reference/reservedNamesInAliases.errors.txt +++ b/tests/baselines/reference/reservedNamesInAliases.errors.txt @@ -1,14 +1,26 @@ tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,6): error TS1003: Identifier expected. tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,11): error TS1005: ';' expected. +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(2,6): error TS2457: Type alias name cannot be 'any' +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(3,6): error TS2457: Type alias name cannot be 'number' +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(4,6): error TS2457: Type alias name cannot be 'boolean' +tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(5,6): error TS2457: Type alias name cannot be 'string' tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,13): error TS2304: Cannot find name 'I'. -==== tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts (3 errors) ==== +==== tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts (7 errors) ==== interface I {} type any = I; + ~~~ +!!! error TS2457: Type alias name cannot be 'any' type number = I; + ~~~~~~ +!!! error TS2457: Type alias name cannot be 'number' type boolean = I; + ~~~~~~~ +!!! error TS2457: Type alias name cannot be 'boolean' type string = I; + ~~~~~~ +!!! error TS2457: Type alias name cannot be 'string' type void = I; ~~~~ !!! error TS1003: Identifier expected. From 6b1a96ca29a8cf34b03865b4f2e840e5f33fb41b Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sun, 2 Nov 2014 13:34:04 -0800 Subject: [PATCH 3/4] added basic set of tests for type aliases --- tests/baselines/reference/typeAliases.js | 110 ++++++++- tests/baselines/reference/typeAliases.types | 212 ++++++++++++++++-- .../types/typeAliases/typeAliases.ts | 73 +++++- 3 files changed, 369 insertions(+), 26 deletions(-) diff --git a/tests/baselines/reference/typeAliases.js b/tests/baselines/reference/typeAliases.js index 6a43fc8b701..0cf0dd92402 100644 --- a/tests/baselines/reference/typeAliases.js +++ b/tests/baselines/reference/typeAliases.js @@ -1,30 +1,126 @@ //// [typeAliases.ts] // Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. +type T1 = number; +var x1: number; +var x1: T1; + +type T2 = string; +var x2: string; +var x2: T2; + +type T3 = boolean; +var x3: boolean; +var x3: T3; + +type T4 = void; +var x4: void; +var x4: T4; + +type T5 = any; +var x5: any; +var x5: T5; + +interface I6 { x : string } +type T6 = I6; +var x6: I6; +var x6: T6; + +class C7 { x: boolean } +type T7 = C7; +var x7: C7; +var x7: T7; + +type T8 = string | boolean; +var x8: string | boolean; +var x8: T8; + +type T9 = () => string; +var x9: () => string; +var x9: T9; + +type T10 = { x: number }; +var x10: { x: number }; +var x10: T10; + +type T11 = { new(): boolean }; +var x11: { new(): boolean }; +var x11: T11; + +interface I13 { x: string }; +type T13 = I13; +var x13_1: I13; +var x13_2: T13 + +declare function foo13(t1: T1, t2: T13): void; +foo13(x13_1, x13_2); +foo13(x13_2, x13_1); + +type T14 = string; +var x14: T14; + +declare function foo14_1(x: T14): void; + +declare function foo14_2(x: "click"): void; +declare function foo14_2(x: T14): void; + type Meters = number enum E { x = 10 } -declare function f(a: string): boolean; -declare function f(a: Meters): string; -f(E.x).toLowerCase(); +declare function f15(a: string): boolean; +declare function f15(a: Meters): string; +f15(E.x).toLowerCase(); type StringAndBoolean = [string, boolean] -declare function f1(s: StringAndBoolean): string; +declare function f16(s: StringAndBoolean): string; var x: [string, boolean]; -f1(x); +f16(x); var y: StringAndBoolean = ["1", false]; y[0].toLowerCase(); //// [typeAliases.js] // Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. +var x1; +var x1; +var x2; +var x2; +var x3; +var x3; +var x4; +var x4; +var x5; +var x5; +var x6; +var x6; +var C7 = (function () { + function C7() { + } + return C7; +})(); +var x7; +var x7; +var x8; +var x8; +var x9; +var x9; +var x10; +var x10; +var x11; +var x11; +; +var x13_1; +var x13_2; +foo13(x13_1, x13_2); +foo13(x13_2, x13_1); +var x14; var E; (function (E) { E[E["x"] = 10] = "x"; })(E || (E = {})); -f(10 /* x */).toLowerCase(); +f15(10 /* x */).toLowerCase(); var x; -f1(x); +f16(x); var y = ["1", false]; y[0].toLowerCase(); diff --git a/tests/baselines/reference/typeAliases.types b/tests/baselines/reference/typeAliases.types index c91d39c5805..f6e4afd571e 100644 --- a/tests/baselines/reference/typeAliases.types +++ b/tests/baselines/reference/typeAliases.types @@ -1,6 +1,190 @@ === tests/cases/conformance/types/typeAliases/typeAliases.ts === // Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. +type T1 = number; +>T1 : number + +var x1: number; +>x1 : number + +var x1: T1; +>x1 : number +>T1 : number + +type T2 = string; +>T2 : string + +var x2: string; +>x2 : string + +var x2: T2; +>x2 : string +>T2 : string + +type T3 = boolean; +>T3 : boolean + +var x3: boolean; +>x3 : boolean + +var x3: T3; +>x3 : boolean +>T3 : boolean + +type T4 = void; +>T4 : void + +var x4: void; +>x4 : void + +var x4: T4; +>x4 : void +>T4 : void + +type T5 = any; +>T5 : any + +var x5: any; +>x5 : any + +var x5: T5; +>x5 : any +>T5 : any + +interface I6 { x : string } +>I6 : I6 +>x : string + +type T6 = I6; +>T6 : I6 +>I6 : I6 + +var x6: I6; +>x6 : I6 +>I6 : I6 + +var x6: T6; +>x6 : I6 +>T6 : I6 + +class C7 { x: boolean } +>C7 : C7 +>x : boolean + +type T7 = C7; +>T7 : C7 +>C7 : C7 + +var x7: C7; +>x7 : C7 +>C7 : C7 + +var x7: T7; +>x7 : C7 +>T7 : C7 + +type T8 = string | boolean; +>T8 : string | boolean + +var x8: string | boolean; +>x8 : string | boolean + +var x8: T8; +>x8 : string | boolean +>T8 : string | boolean + +type T9 = () => string; +>T9 : () => string + +var x9: () => string; +>x9 : () => string + +var x9: T9; +>x9 : () => string +>T9 : () => string + +type T10 = { x: number }; +>T10 : { x: number; } +>x : number + +var x10: { x: number }; +>x10 : { x: number; } +>x : number + +var x10: T10; +>x10 : { x: number; } +>T10 : { x: number; } + +type T11 = { new(): boolean }; +>T11 : new () => boolean + +var x11: { new(): boolean }; +>x11 : new () => boolean + +var x11: T11; +>x11 : new () => boolean +>T11 : new () => boolean + +interface I13 { x: string }; +>I13 : I13 +>x : string + +type T13 = I13; +>T13 : I13 +>I13 : I13 + +var x13_1: I13; +>x13_1 : I13 +>I13 : I13 + +var x13_2: T13 +>x13_2 : I13 +>T13 : I13 + +declare function foo13(t1: T1, t2: T13): void; +>foo13 : (t1: T1, t2: I13) => void +>T1 : T1 +>I13 : I13 +>T2 : T2 +>T13 : I13 +>t1 : T1 +>T1 : T1 +>t2 : I13 +>T13 : I13 + +foo13(x13_1, x13_2); +>foo13(x13_1, x13_2) : void +>foo13 : (t1: T1, t2: I13) => void +>x13_1 : I13 +>x13_2 : I13 + +foo13(x13_2, x13_1); +>foo13(x13_2, x13_1) : void +>foo13 : (t1: T1, t2: I13) => void +>x13_2 : I13 +>x13_1 : I13 + +type T14 = string; +>T14 : string + +var x14: T14; +>x14 : string +>T14 : string + +declare function foo14_1(x: T14): void; +>foo14_1 : (x: string) => void +>x : string +>T14 : string + +declare function foo14_2(x: "click"): void; +>foo14_2 : { (x: "click"): void; (x: string): void; } +>x : "click" + +declare function foo14_2(x: T14): void; +>foo14_2 : { (x: "click"): void; (x: string): void; } +>x : string +>T14 : string + type Meters = number >Meters : number @@ -8,20 +192,20 @@ enum E { x = 10 } >E : E >x : E -declare function f(a: string): boolean; ->f : { (a: string): boolean; (a: number): string; } +declare function f15(a: string): boolean; +>f15 : { (a: string): boolean; (a: number): string; } >a : string -declare function f(a: Meters): string; ->f : { (a: string): boolean; (a: number): string; } +declare function f15(a: Meters): string; +>f15 : { (a: string): boolean; (a: number): string; } >a : number >Meters : number -f(E.x).toLowerCase(); ->f(E.x).toLowerCase() : string ->f(E.x).toLowerCase : () => string ->f(E.x) : string ->f : { (a: string): boolean; (a: number): string; } +f15(E.x).toLowerCase(); +>f15(E.x).toLowerCase() : string +>f15(E.x).toLowerCase : () => string +>f15(E.x) : string +>f15 : { (a: string): boolean; (a: number): string; } >E.x : E >E : typeof E >x : E @@ -30,17 +214,17 @@ f(E.x).toLowerCase(); type StringAndBoolean = [string, boolean] >StringAndBoolean : [string, boolean] -declare function f1(s: StringAndBoolean): string; ->f1 : (s: [string, boolean]) => string +declare function f16(s: StringAndBoolean): string; +>f16 : (s: [string, boolean]) => string >s : [string, boolean] >StringAndBoolean : [string, boolean] var x: [string, boolean]; >x : [string, boolean] -f1(x); ->f1(x) : string ->f1 : (s: [string, boolean]) => string +f16(x); +>f16(x) : string +>f16 : (s: [string, boolean]) => string >x : [string, boolean] var y: StringAndBoolean = ["1", false]; diff --git a/tests/cases/conformance/types/typeAliases/typeAliases.ts b/tests/cases/conformance/types/typeAliases/typeAliases.ts index 72cbcb7a4a6..b9d28f4cc35 100644 --- a/tests/cases/conformance/types/typeAliases/typeAliases.ts +++ b/tests/cases/conformance/types/typeAliases/typeAliases.ts @@ -1,17 +1,80 @@ // Writing a reference to a type alias has exactly the same effect as writing the aliased type itself. +type T1 = number; +var x1: number; +var x1: T1; + +type T2 = string; +var x2: string; +var x2: T2; + +type T3 = boolean; +var x3: boolean; +var x3: T3; + +type T4 = void; +var x4: void; +var x4: T4; + +type T5 = any; +var x5: any; +var x5: T5; + +interface I6 { x : string } +type T6 = I6; +var x6: I6; +var x6: T6; + +class C7 { x: boolean } +type T7 = C7; +var x7: C7; +var x7: T7; + +type T8 = string | boolean; +var x8: string | boolean; +var x8: T8; + +type T9 = () => string; +var x9: () => string; +var x9: T9; + +type T10 = { x: number }; +var x10: { x: number }; +var x10: T10; + +type T11 = { new(): boolean }; +var x11: { new(): boolean }; +var x11: T11; + +interface I13 { x: string }; +type T13 = I13; +var x13_1: I13; +var x13_2: T13 + +declare function foo13(t1: T1, t2: T13): void; +foo13(x13_1, x13_2); +foo13(x13_2, x13_1); + +type T14 = string; +var x14: T14; + +declare function foo14_1(x: T14): void; + +declare function foo14_2(x: "click"): void; +declare function foo14_2(x: T14): void; + type Meters = number enum E { x = 10 } -declare function f(a: string): boolean; -declare function f(a: Meters): string; -f(E.x).toLowerCase(); +declare function f15(a: string): boolean; +declare function f15(a: Meters): string; +f15(E.x).toLowerCase(); type StringAndBoolean = [string, boolean] -declare function f1(s: StringAndBoolean): string; +declare function f16(s: StringAndBoolean): string; var x: [string, boolean]; -f1(x); +f16(x); var y: StringAndBoolean = ["1", false]; y[0].toLowerCase(); \ No newline at end of file From cba9b7ff5ef42f30f5b16de526f9ab0131762352 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Sun, 2 Nov 2014 16:20:00 -0800 Subject: [PATCH 4/4] fixed typo --- .../reference/directDependenceBetweenTypeAliases.errors.txt | 2 +- tests/baselines/reference/directDependenceBetweenTypeAliases.js | 2 +- .../types/typeAliases/directDependenceBetweenTypeAliases.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt index 2d269f7744b..b9890e925c4 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt @@ -67,6 +67,6 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( type T11 = T12[] type T12 = [T13, string] type T13 = typeof zz - var zz: { x: T10 } + var zz: { x: T11 } \ No newline at end of file diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.js b/tests/baselines/reference/directDependenceBetweenTypeAliases.js index cfa8b9e532b..370e33483fc 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.js +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.js @@ -38,7 +38,7 @@ type T10 = { x: T10 } | { new(v: T10): string } type T11 = T12[] type T12 = [T13, string] type T13 = typeof zz -var zz: { x: T10 } +var zz: { x: T11 } diff --git a/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts b/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts index 16aafec627d..049a0101f5d 100644 --- a/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts +++ b/tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts @@ -37,5 +37,5 @@ type T10 = { x: T10 } | { new(v: T10): string } type T11 = T12[] type T12 = [T13, string] type T13 = typeof zz -var zz: { x: T10 } +var zz: { x: T11 }