diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt new file mode 100644 index 0000000000000..ca8ceb6d3ec18 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt @@ -0,0 +1,6 @@ +==== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts (1 errors) ==== + module M { + export declare module "M" { } + ~~~ +!!! Ambient external modules cannot be nested in other modules. + } \ No newline at end of file diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.js b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.js new file mode 100644 index 0000000000000..0d06147e802e9 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.js @@ -0,0 +1,6 @@ +//// [ambientExternalModuleInsideNonAmbient.ts] +module M { + export declare module "M" { } +} + +//// [ambientExternalModuleInsideNonAmbient.js] diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt new file mode 100644 index 0000000000000..44731cf625052 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt @@ -0,0 +1,4 @@ +==== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts (1 errors) ==== + export declare module "M" { } + ~~~ +!!! Ambient external modules cannot be nested in other modules. \ No newline at end of file diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.js b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.js new file mode 100644 index 0000000000000..8a3e15e7c7f46 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.js @@ -0,0 +1,6 @@ +//// [ambientExternalModuleInsideNonAmbientExternalModule.ts] +export declare module "M" { } + +//// [ambientExternalModuleInsideNonAmbientExternalModule.js] +define(["require", "exports"], function (require, exports) { +}); diff --git a/tests/baselines/reference/ambientExternalModuleMerging.js b/tests/baselines/reference/ambientExternalModuleMerging.js new file mode 100644 index 0000000000000..1549b725d670f --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleMerging.js @@ -0,0 +1,25 @@ +//// [tests/cases/conformance/ambient/ambientExternalModuleMerging.ts] //// + +//// [ambientExternalModuleMerging_use.ts] +import M = require("M"); +// Should be strings +var x = M.x; +var y = M.y; + +//// [ambientExternalModuleMerging_declare.ts] +declare module "M" { + export var x: string; +} + +// Merge +declare module "M" { + export var y: string; +} + +//// [ambientExternalModuleMerging_use.js] +define(["require", "exports", "M"], function (require, exports, M) { + // Should be strings + var x = M.x; + var y = M.y; +}); +//// [ambientExternalModuleMerging_declare.js] diff --git a/tests/baselines/reference/ambientExternalModuleMerging.types b/tests/baselines/reference/ambientExternalModuleMerging.types new file mode 100644 index 0000000000000..1c1be0fd25665 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleMerging.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/ambient/ambientExternalModuleMerging_use.ts === +import M = require("M"); +>M : typeof M + +// Should be strings +var x = M.x; +>x : string +>M.x : string +>M : typeof M +>x : string + +var y = M.y; +>y : string +>M.y : string +>M : typeof M +>y : string + +=== tests/cases/conformance/ambient/ambientExternalModuleMerging_declare.ts === +declare module "M" { + export var x: string; +>x : string +} + +// Merge +declare module "M" { + export var y: string; +>y : string +} diff --git a/tests/baselines/reference/ambientInsideNonAmbient.js b/tests/baselines/reference/ambientInsideNonAmbient.js new file mode 100644 index 0000000000000..9a3c5558e0732 --- /dev/null +++ b/tests/baselines/reference/ambientInsideNonAmbient.js @@ -0,0 +1,24 @@ +//// [ambientInsideNonAmbient.ts] +module M { + export declare var x; + export declare function f(); + export declare class C { } + export declare enum E { } + export declare module M { } +} + +module M2 { + declare var x; + declare function f(); + declare class C { } + declare enum E { } + declare module M { } +} + +//// [ambientInsideNonAmbient.js] +var M; +(function (M) { +})(M || (M = {})); +var M2; +(function (M2) { +})(M2 || (M2 = {})); diff --git a/tests/baselines/reference/ambientInsideNonAmbient.types b/tests/baselines/reference/ambientInsideNonAmbient.types new file mode 100644 index 0000000000000..ee654aee33348 --- /dev/null +++ b/tests/baselines/reference/ambientInsideNonAmbient.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/ambient/ambientInsideNonAmbient.ts === +module M { +>M : typeof M + + export declare var x; +>x : any + + export declare function f(); +>f : () => any + + export declare class C { } +>C : C + + export declare enum E { } +>E : E + + export declare module M { } +>M : unknown +} + +module M2 { +>M2 : typeof M2 + + declare var x; +>x : any + + declare function f(); +>f : () => any + + declare class C { } +>C : C + + declare enum E { } +>E : E + + declare module M { } +>M : unknown +} diff --git a/tests/baselines/reference/ambientInsideNonAmbientExternalModule.js b/tests/baselines/reference/ambientInsideNonAmbientExternalModule.js new file mode 100644 index 0000000000000..5db44bb1ce127 --- /dev/null +++ b/tests/baselines/reference/ambientInsideNonAmbientExternalModule.js @@ -0,0 +1,10 @@ +//// [ambientInsideNonAmbientExternalModule.ts] +export declare var x; +export declare function f(); +export declare class C { } +export declare enum E { } +export declare module M { } + +//// [ambientInsideNonAmbientExternalModule.js] +define(["require", "exports"], function (require, exports) { +}); diff --git a/tests/baselines/reference/ambientInsideNonAmbientExternalModule.types b/tests/baselines/reference/ambientInsideNonAmbientExternalModule.types new file mode 100644 index 0000000000000..bda7a61a7f3ce --- /dev/null +++ b/tests/baselines/reference/ambientInsideNonAmbientExternalModule.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/ambient/ambientInsideNonAmbientExternalModule.ts === +export declare var x; +>x : any + +export declare function f(); +>f : () => any + +export declare class C { } +>C : C + +export declare enum E { } +>E : E + +export declare module M { } +>M : unknown + diff --git a/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.errors.txt b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.errors.txt index 19824374ebdaf..4222ab54b1551 100644 --- a/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.errors.txt +++ b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.errors.txt @@ -1,4 +1,4 @@ -==== tests/cases/compiler/augmentedTypeAssignmentCompatIndexSignature.ts (2 errors) ==== +==== tests/cases/conformance/types/members/augmentedTypeAssignmentCompatIndexSignature.ts (2 errors) ==== interface Foo { a } interface Bar { b } diff --git a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.types b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.types index d02a36409a78c..4e6b51730daf4 100644 --- a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.types +++ b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.types @@ -1,4 +1,4 @@ -=== tests/cases/compiler/augmentedTypeBracketAccessIndexSignature.ts === +=== tests/cases/conformance/types/members/augmentedTypeBracketAccessIndexSignature.ts === interface Foo { a } >Foo : Foo >a : any diff --git a/tests/baselines/reference/classDoesNotDependOnPrivateMember.js b/tests/baselines/reference/classDoesNotDependOnPrivateMember.js new file mode 100644 index 0000000000000..548c94b0ea736 --- /dev/null +++ b/tests/baselines/reference/classDoesNotDependOnPrivateMember.js @@ -0,0 +1,26 @@ +//// [classDoesNotDependOnPrivateMember.ts] +module M { + interface I { } + export class C { + private x: I; + } +} + +//// [classDoesNotDependOnPrivateMember.js] +var M; +(function (M) { + var C = (function () { + function C() { + } + return C; + })(); + M.C = C; +})(M || (M = {})); + + +//// [classDoesNotDependOnPrivateMember.d.ts] +declare module M { + class C { + private x; + } +} diff --git a/tests/baselines/reference/classDoesNotDependOnPrivateMember.types b/tests/baselines/reference/classDoesNotDependOnPrivateMember.types new file mode 100644 index 0000000000000..213c46ca1d584 --- /dev/null +++ b/tests/baselines/reference/classDoesNotDependOnPrivateMember.types @@ -0,0 +1,15 @@ +=== tests/cases/conformance/declarationEmit/classDoesNotDependOnPrivateMember.ts === +module M { +>M : typeof M + + interface I { } +>I : I + + export class C { +>C : C + + private x: I; +>x : I +>I : I + } +} diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.js b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.js new file mode 100644 index 0000000000000..05bf593703947 --- /dev/null +++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.js @@ -0,0 +1,28 @@ +//// [contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts] +declare function foo(x: (y: string) => (y2: number) => void); + +// Contextually type the parameter even if there is a return annotation +foo((y): (y2: number) => void => { + var z = y.charAt(0); // Should be string + return null; +}); + +foo((y: string) => { + return y2 => { + var z = y2.toFixed(); // Should be string + return 0; + }; +}); + +//// [contextuallyTypedFunctionExpressionsAndReturnAnnotations.js] +// Contextually type the parameter even if there is a return annotation +foo(function (y) { + var z = y.charAt(0); // Should be string + return null; +}); +foo(function (y) { + return function (y2) { + var z = y2.toFixed(); // Should be string + return 0; + }; +}); diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.types b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.types new file mode 100644 index 0000000000000..09c317c64a09b --- /dev/null +++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.types @@ -0,0 +1,45 @@ +=== tests/cases/conformance/expressions/functions/contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts === +declare function foo(x: (y: string) => (y2: number) => void); +>foo : (x: (y: string) => (y2: number) => void) => any +>x : (y: string) => (y2: number) => void +>y : string +>y2 : number + +// Contextually type the parameter even if there is a return annotation +foo((y): (y2: number) => void => { +>foo((y): (y2: number) => void => { var z = y.charAt(0); // Should be string return null;}) : any +>foo : (x: (y: string) => (y2: number) => void) => any +>(y): (y2: number) => void => { var z = y.charAt(0); // Should be string return null;} : (y: string) => (y2: number) => void +>y : string +>y2 : number + + var z = y.charAt(0); // Should be string +>z : string +>y.charAt(0) : string +>y.charAt : (pos: number) => string +>y : string +>charAt : (pos: number) => string + + return null; +}); + +foo((y: string) => { +>foo((y: string) => { return y2 => { var z = y2.toFixed(); // Should be string return 0; };}) : any +>foo : (x: (y: string) => (y2: number) => void) => any +>(y: string) => { return y2 => { var z = y2.toFixed(); // Should be string return 0; };} : (y: string) => (y2: number) => number +>y : string + + return y2 => { +>y2 => { var z = y2.toFixed(); // Should be string return 0; } : (y2: number) => number +>y2 : number + + var z = y2.toFixed(); // Should be string +>z : string +>y2.toFixed() : string +>y2.toFixed : (fractionDigits?: number) => string +>y2 : number +>toFixed : (fractionDigits?: number) => string + + return 0; + }; +}); diff --git a/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.js b/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.js new file mode 100644 index 0000000000000..2cce6e7220959 --- /dev/null +++ b/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.js @@ -0,0 +1,13 @@ +//// [derivedInterfaceDoesNotHideBaseSignatures.ts] +// Derived interfaces no longer hide signatures from base types, so these signatures are always compatible. +interface Base { + (): string; + new (x: string): number; +} + +interface Derived extends Base { + (): number; + new (x: string): string; +} + +//// [derivedInterfaceDoesNotHideBaseSignatures.js] diff --git a/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.types b/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.types new file mode 100644 index 0000000000000..7ee090b7de3b9 --- /dev/null +++ b/tests/baselines/reference/derivedInterfaceDoesNotHideBaseSignatures.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/interfaces/interfaceDeclarations/derivedInterfaceDoesNotHideBaseSignatures.ts === +// Derived interfaces no longer hide signatures from base types, so these signatures are always compatible. +interface Base { +>Base : Base + + (): string; + new (x: string): number; +>x : string +} + +interface Derived extends Base { +>Derived : Derived +>Base : Base + + (): number; + new (x: string): string; +>x : string +} diff --git a/tests/baselines/reference/enumConstantMembers.errors.txt b/tests/baselines/reference/enumConstantMembers.errors.txt new file mode 100644 index 0000000000000..ac77e2b7b4ea7 --- /dev/null +++ b/tests/baselines/reference/enumConstantMembers.errors.txt @@ -0,0 +1,24 @@ +==== tests/cases/conformance/enums/enumConstantMembers.ts (2 errors) ==== + // Constant members allow negatives, but not decimals. Also hex literals are allowed + enum E1 { + a = 1, + b + } + enum E2 { + a = - 1, + b + } + enum E3 { + a = 0.1, + b // Error because 0.1 is not a constant + ~ +!!! Enum member must have initializer. + } + + declare enum E4 { + a = 1, + b = -1, + c = 0.1 // Not a constant + ~ +!!! Ambient enum elements can only have integer literal initializers. + } \ No newline at end of file diff --git a/tests/baselines/reference/forgottenNew.errors.txt b/tests/baselines/reference/forgottenNew.errors.txt index 3a6d490a0e9cb..ba44223819c20 100644 --- a/tests/baselines/reference/forgottenNew.errors.txt +++ b/tests/baselines/reference/forgottenNew.errors.txt @@ -1,4 +1,4 @@ -==== tests/cases/compiler/forgottenNew.ts (1 errors) ==== +==== tests/cases/conformance/expressions/functionCalls/forgottenNew.ts (1 errors) ==== module Tools { export class NullLogger { } } diff --git a/tests/baselines/reference/indexSignatureTypeInference.errors.txt b/tests/baselines/reference/indexSignatureTypeInference.errors.txt index a37e445854309..ee42069a4ecca 100644 --- a/tests/baselines/reference/indexSignatureTypeInference.errors.txt +++ b/tests/baselines/reference/indexSignatureTypeInference.errors.txt @@ -1,4 +1,4 @@ -==== tests/cases/compiler/indexSignatureTypeInference.ts (1 errors) ==== +==== tests/cases/conformance/types/typeRelationships/typeInference/indexSignatureTypeInference.ts (1 errors) ==== interface NumberMap { [index: number]: T; } diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.js b/tests/baselines/reference/recursiveTypesWithTypeof.js new file mode 100644 index 0000000000000..36c13405b0bd8 --- /dev/null +++ b/tests/baselines/reference/recursiveTypesWithTypeof.js @@ -0,0 +1,99 @@ +//// [recursiveTypesWithTypeof.ts] +// None of these declarations should have any errors! +// Using typeof directly, these should be any +var c: typeof c; +var c: any; +var d: typeof e; +var d: any; +var e: typeof d; +var e: any; + +// In type arguments, these should be any +interface Foo { } +var f: Array; +var f: any; +var f2: Foo; +var f2: any; +var f3: Foo[]; +var f3: any; + +// Truly recursive types +var g: { x: typeof g; }; +var g: typeof g.x; +var h: () => typeof h; +var h = h(); +var i: (x: typeof i) => typeof x; +var i = i(i); +var j: (x: T) => T; +var j = j(j); + +// Same as h, i, j with construct signatures +var h2: new () => typeof h2; +var h2 = new h2(); +var i2: new (x: typeof i2) => typeof x; +var i2 = new i2(i2); +var j2: new (x: T) => T; +var j2 = new j2(j2); + +// Indexers +var k: { [n: number]: typeof k;[s: string]: typeof k }; +var k = k[0]; +var k = k['']; + +// Hybrid - contains type literals as well as type arguments +// These two are recursive +var hy1: { x: typeof hy1 }[]; +var hy1 = hy1[0].x; +var hy2: { x: Array }; +var hy2 = hy2.x[0]; + +interface Foo2 { } + +// This one should be any because the first type argument is not contained inside a type literal +var hy3: Foo2; +var hy3: any; + +//// [recursiveTypesWithTypeof.js] +// None of these declarations should have any errors! +// Using typeof directly, these should be any +var c; +var c; +var d; +var d; +var e; +var e; +var f; +var f; +var f2; +var f2; +var f3; +var f3; +// Truly recursive types +var g; +var g; +var h; +var h = h(); +var i; +var i = i(i); +var j; +var j = j(j); +// Same as h, i, j with construct signatures +var h2; +var h2 = new h2(); +var i2; +var i2 = new i2(i2); +var j2; +var j2 = new j2(j2); +// Indexers +var k; +var k = k[0]; +var k = k['']; +// Hybrid - contains type literals as well as type arguments +// These two are recursive +var hy1; +var hy1 = hy1[0].x; +var hy2; +var hy2 = hy2.x[0]; +// This one should be any because the first type argument is not contained inside a type literal +var hy3; +var hy3; diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.types b/tests/baselines/reference/recursiveTypesWithTypeof.types new file mode 100644 index 0000000000000..f75bae79c5b7c --- /dev/null +++ b/tests/baselines/reference/recursiveTypesWithTypeof.types @@ -0,0 +1,196 @@ +=== tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts === +// None of these declarations should have any errors! +// Using typeof directly, these should be any +var c: typeof c; +>c : any +>c : any + +var c: any; +>c : any + +var d: typeof e; +>d : any +>e : any + +var d: any; +>d : any + +var e: typeof d; +>e : any +>d : any + +var e: any; +>e : any + +// In type arguments, these should be any +interface Foo { } +>Foo : Foo +>T : T + +var f: Array; +>f : any +>Array : T[] +>f : any + +var f: any; +>f : any + +var f2: Foo; +>f2 : any +>Foo : Foo +>f2 : any + +var f2: any; +>f2 : any + +var f3: Foo[]; +>f3 : any +>Foo : Foo +>f3 : any + +var f3: any; +>f3 : any + +// Truly recursive types +var g: { x: typeof g; }; +>g : { x: any; } +>x : { x: any; } +>g : { x: any; } + +var g: typeof g.x; +>g : { x: any; } +>g : { x: any; } +>x : { x: any; } + +var h: () => typeof h; +>h : () => any +>h : () => any + +var h = h(); +>h : () => any +>h() : () => any +>h : () => any + +var i: (x: typeof i) => typeof x; +>i : (x: any) => any +>x : (x: any) => any +>i : (x: any) => any +>x : (x: any) => any + +var i = i(i); +>i : (x: any) => any +>i(i) : (x: any) => any +>i : (x: any) => any +>i : (x: any) => any + +var j: (x: T) => T; +>j : (x: T) => T +>T : T +>j : (x: T) => T +>x : T +>T : T +>T : T + +var j = j(j); +>j : (x: T) => T +>j(j) : (x: T) => T +>j : (x: T) => T +>j : (x: T) => T + +// Same as h, i, j with construct signatures +var h2: new () => typeof h2; +>h2 : new () => any +>h2 : new () => any + +var h2 = new h2(); +>h2 : new () => any +>new h2() : new () => any +>h2 : new () => any + +var i2: new (x: typeof i2) => typeof x; +>i2 : new (x: any) => any +>x : new (x: any) => any +>i2 : new (x: any) => any +>x : new (x: any) => any + +var i2 = new i2(i2); +>i2 : new (x: any) => any +>new i2(i2) : new (x: any) => any +>i2 : new (x: any) => any +>i2 : new (x: any) => any + +var j2: new (x: T) => T; +>j2 : new (x: T) => T +>T : T +>j2 : new (x: T) => T +>x : T +>T : T +>T : T + +var j2 = new j2(j2); +>j2 : new (x: T) => T +>new j2(j2) : new (x: T) => T +>j2 : new (x: T) => T +>j2 : new (x: T) => T + +// Indexers +var k: { [n: number]: typeof k;[s: string]: typeof k }; +>k : { [x: string]: any; [x: number]: any; } +>n : number +>k : { [x: string]: any; [x: number]: any; } +>s : string +>k : { [x: string]: any; [x: number]: any; } + +var k = k[0]; +>k : { [x: string]: any; [x: number]: any; } +>k[0] : { [x: string]: any; [x: number]: any; } +>k : { [x: string]: any; [x: number]: any; } + +var k = k['']; +>k : { [x: string]: any; [x: number]: any; } +>k[''] : { [x: string]: any; [x: number]: any; } +>k : { [x: string]: any; [x: number]: any; } + +// Hybrid - contains type literals as well as type arguments +// These two are recursive +var hy1: { x: typeof hy1 }[]; +>hy1 : { x: any[]; }[] +>x : { x: any[]; }[] +>hy1 : { x: any[]; }[] + +var hy1 = hy1[0].x; +>hy1 : { x: any[]; }[] +>hy1[0].x : { x: any[]; }[] +>hy1[0] : { x: any[]; } +>hy1 : { x: any[]; }[] +>x : { x: any[]; }[] + +var hy2: { x: Array }; +>hy2 : { x: any[]; } +>x : { x: any[]; }[] +>Array : T[] +>hy2 : { x: any[]; } + +var hy2 = hy2.x[0]; +>hy2 : { x: any[]; } +>hy2.x[0] : { x: any[]; } +>hy2.x : { x: any[]; }[] +>hy2 : { x: any[]; } +>x : { x: any[]; }[] + +interface Foo2 { } +>Foo2 : Foo2 +>T : T +>U : U + +// This one should be any because the first type argument is not contained inside a type literal +var hy3: Foo2; +>hy3 : any +>Foo2 : Foo2 +>hy3 : any +>x : any +>hy3 : any + +var hy3: any; +>hy3 : any + diff --git a/tests/baselines/reference/specializedSignatureWithOptional.js b/tests/baselines/reference/specializedSignatureWithOptional.js new file mode 100644 index 0000000000000..aea08090b55a2 --- /dev/null +++ b/tests/baselines/reference/specializedSignatureWithOptional.js @@ -0,0 +1,5 @@ +//// [specializedSignatureWithOptional.ts] +declare function f(x?: "hi"): void; +declare function f(x?: string): void; + +//// [specializedSignatureWithOptional.js] diff --git a/tests/baselines/reference/specializedSignatureWithOptional.types b/tests/baselines/reference/specializedSignatureWithOptional.types new file mode 100644 index 0000000000000..73cd89edb30ef --- /dev/null +++ b/tests/baselines/reference/specializedSignatureWithOptional.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureWithOptional.ts === +declare function f(x?: "hi"): void; +>f : { (x?: "hi"): void; (x?: string): void; } +>x : "hi" + +declare function f(x?: string): void; +>f : { (x?: "hi"): void; (x?: string): void; } +>x : string + diff --git a/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts b/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts new file mode 100644 index 0000000000000..9a7264437297f --- /dev/null +++ b/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts @@ -0,0 +1,3 @@ +module M { + export declare module "M" { } +} \ No newline at end of file diff --git a/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts b/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts new file mode 100644 index 0000000000000..027dc4d300869 --- /dev/null +++ b/tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts @@ -0,0 +1,2 @@ +//@module: amd +export declare module "M" { } \ No newline at end of file diff --git a/tests/cases/conformance/ambient/ambientExternalModuleMerging.ts b/tests/cases/conformance/ambient/ambientExternalModuleMerging.ts new file mode 100644 index 0000000000000..432ac69382106 --- /dev/null +++ b/tests/cases/conformance/ambient/ambientExternalModuleMerging.ts @@ -0,0 +1,16 @@ +//@filename: ambientExternalModuleMerging_use.ts +//@module: amd +import M = require("M"); +// Should be strings +var x = M.x; +var y = M.y; + +//@filename: ambientExternalModuleMerging_declare.ts +declare module "M" { + export var x: string; +} + +// Merge +declare module "M" { + export var y: string; +} \ No newline at end of file diff --git a/tests/cases/conformance/ambient/ambientInsideNonAmbient.ts b/tests/cases/conformance/ambient/ambientInsideNonAmbient.ts new file mode 100644 index 0000000000000..e2f24113c94fa --- /dev/null +++ b/tests/cases/conformance/ambient/ambientInsideNonAmbient.ts @@ -0,0 +1,15 @@ +module M { + export declare var x; + export declare function f(); + export declare class C { } + export declare enum E { } + export declare module M { } +} + +module M2 { + declare var x; + declare function f(); + declare class C { } + declare enum E { } + declare module M { } +} \ No newline at end of file diff --git a/tests/cases/conformance/ambient/ambientInsideNonAmbientExternalModule.ts b/tests/cases/conformance/ambient/ambientInsideNonAmbientExternalModule.ts new file mode 100644 index 0000000000000..dbdc315c7432e --- /dev/null +++ b/tests/cases/conformance/ambient/ambientInsideNonAmbientExternalModule.ts @@ -0,0 +1,6 @@ +// @module: amd +export declare var x; +export declare function f(); +export declare class C { } +export declare enum E { } +export declare module M { } \ No newline at end of file diff --git a/tests/cases/conformance/declarationEmit/classDoesNotDependOnPrivateMember.ts b/tests/cases/conformance/declarationEmit/classDoesNotDependOnPrivateMember.ts new file mode 100644 index 0000000000000..4f0e9f7f4e5e1 --- /dev/null +++ b/tests/cases/conformance/declarationEmit/classDoesNotDependOnPrivateMember.ts @@ -0,0 +1,7 @@ +//@declaration: true +module M { + interface I { } + export class C { + private x: I; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/enums/enumConstantMembers.ts b/tests/cases/conformance/enums/enumConstantMembers.ts new file mode 100644 index 0000000000000..e56828db06409 --- /dev/null +++ b/tests/cases/conformance/enums/enumConstantMembers.ts @@ -0,0 +1,19 @@ +// Constant members allow negatives, but not decimals. Also hex literals are allowed +enum E1 { + a = 1, + b +} +enum E2 { + a = - 1, + b +} +enum E3 { + a = 0.1, + b // Error because 0.1 is not a constant +} + +declare enum E4 { + a = 1, + b = -1, + c = 0.1 // Not a constant +} \ No newline at end of file diff --git a/tests/cases/compiler/forgottenNew.ts b/tests/cases/conformance/expressions/functionCalls/forgottenNew.ts similarity index 100% rename from tests/cases/compiler/forgottenNew.ts rename to tests/cases/conformance/expressions/functionCalls/forgottenNew.ts diff --git a/tests/cases/conformance/expressions/functions/contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts b/tests/cases/conformance/expressions/functions/contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts new file mode 100644 index 0000000000000..0a1aceaf376a3 --- /dev/null +++ b/tests/cases/conformance/expressions/functions/contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts @@ -0,0 +1,14 @@ +declare function foo(x: (y: string) => (y2: number) => void); + +// Contextually type the parameter even if there is a return annotation +foo((y): (y2: number) => void => { + var z = y.charAt(0); // Should be string + return null; +}); + +foo((y: string) => { + return y2 => { + var z = y2.toFixed(); // Should be string + return 0; + }; +}); \ No newline at end of file diff --git a/tests/cases/conformance/interfaces/interfaceDeclarations/derivedInterfaceDoesNotHideBaseSignatures.ts b/tests/cases/conformance/interfaces/interfaceDeclarations/derivedInterfaceDoesNotHideBaseSignatures.ts new file mode 100644 index 0000000000000..49f67862ef043 --- /dev/null +++ b/tests/cases/conformance/interfaces/interfaceDeclarations/derivedInterfaceDoesNotHideBaseSignatures.ts @@ -0,0 +1,10 @@ +// Derived interfaces no longer hide signatures from base types, so these signatures are always compatible. +interface Base { + (): string; + new (x: string): number; +} + +interface Derived extends Base { + (): number; + new (x: string): string; +} \ No newline at end of file diff --git a/tests/cases/compiler/augmentedTypeAssignmentCompatIndexSignature.ts b/tests/cases/conformance/types/members/augmentedTypeAssignmentCompatIndexSignature.ts similarity index 100% rename from tests/cases/compiler/augmentedTypeAssignmentCompatIndexSignature.ts rename to tests/cases/conformance/types/members/augmentedTypeAssignmentCompatIndexSignature.ts diff --git a/tests/cases/compiler/augmentedTypeBracketAccessIndexSignature.ts b/tests/cases/conformance/types/members/augmentedTypeBracketAccessIndexSignature.ts similarity index 100% rename from tests/cases/compiler/augmentedTypeBracketAccessIndexSignature.ts rename to tests/cases/conformance/types/members/augmentedTypeBracketAccessIndexSignature.ts diff --git a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureWithOptional.ts b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureWithOptional.ts new file mode 100644 index 0000000000000..a601f6b483bd7 --- /dev/null +++ b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/specializedSignatureWithOptional.ts @@ -0,0 +1,2 @@ +declare function f(x?: "hi"): void; +declare function f(x?: string): void; \ No newline at end of file diff --git a/tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts b/tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts new file mode 100644 index 0000000000000..7852f99dd9ba5 --- /dev/null +++ b/tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts @@ -0,0 +1,53 @@ +// None of these declarations should have any errors! +// Using typeof directly, these should be any +var c: typeof c; +var c: any; +var d: typeof e; +var d: any; +var e: typeof d; +var e: any; + +// In type arguments, these should be any +interface Foo { } +var f: Array; +var f: any; +var f2: Foo; +var f2: any; +var f3: Foo[]; +var f3: any; + +// Truly recursive types +var g: { x: typeof g; }; +var g: typeof g.x; +var h: () => typeof h; +var h = h(); +var i: (x: typeof i) => typeof x; +var i = i(i); +var j: (x: T) => T; +var j = j(j); + +// Same as h, i, j with construct signatures +var h2: new () => typeof h2; +var h2 = new h2(); +var i2: new (x: typeof i2) => typeof x; +var i2 = new i2(i2); +var j2: new (x: T) => T; +var j2 = new j2(j2); + +// Indexers +var k: { [n: number]: typeof k;[s: string]: typeof k }; +var k = k[0]; +var k = k['']; + +// Hybrid - contains type literals as well as type arguments +// These two are recursive +var hy1: { x: typeof hy1 }[]; +var hy1 = hy1[0].x; +var hy2: { x: Array }; +var hy2 = hy2.x[0]; + +interface Foo2 { } + +// This one should be any because the first type argument is not contained inside a type literal +var hy3: Foo2; +var hy3: any; \ No newline at end of file diff --git a/tests/cases/compiler/indexSignatureTypeInference.ts b/tests/cases/conformance/types/typeRelationships/typeInference/indexSignatureTypeInference.ts similarity index 100% rename from tests/cases/compiler/indexSignatureTypeInference.ts rename to tests/cases/conformance/types/typeRelationships/typeInference/indexSignatureTypeInference.ts