Merge pull request #621 from Microsoft/specConformanceTests

Conformance coverage for spec change #589

Author: JsonFreeman

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.
+    }

tests/baselines/reference/ambientExternalModuleInsideNonAmbient.js

@@ -0,0 +1,6 @@
+//// [ambientExternalModuleInsideNonAmbient.ts]
+module M {
+    export declare module "M" { }
+}
+
+//// [ambientExternalModuleInsideNonAmbient.js]

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.

tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.js

@@ -0,0 +1,6 @@
+//// [ambientExternalModuleInsideNonAmbientExternalModule.ts]
+export declare module "M" { }
+
+//// [ambientExternalModuleInsideNonAmbientExternalModule.js]
+define(["require", "exports"], function (require, exports) {
+});

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]

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
+}

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 = {}));

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
+}

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) {
+});

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
+

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 }
 

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

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;
+    }
+}

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
+    }
+}

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;
+    };
+});

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;
+    };
+});

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]

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
+}

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.
+    }

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 { }
     }

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<T> {
         [index: number]: T;
     }