Baseline updates now that we emit in the presence of parse errors.

Author: CyrusNajmabadi

tests/baselines/reference/ArrowFunction1.js

@@ -0,0 +1,8 @@
+//// [ArrowFunction1.ts]
+var v = (a: ) => {
+   
+};
+
+//// [ArrowFunction1.js]
+var v = function (a) {
+};

tests/baselines/reference/ArrowFunction3.js

@@ -0,0 +1,8 @@
+//// [ArrowFunction3.ts]
+var v = (a): => {
+   
+};
+
+//// [ArrowFunction3.js]
+var v = function (a) {
+};

tests/baselines/reference/ExportAssignment7.js

@@ -0,0 +1,13 @@
+//// [ExportAssignment7.ts]
+export class C {
+}
+
+export = B;
+
+//// [ExportAssignment7.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+exports.C = C;

tests/baselines/reference/ExportAssignment8.js

@@ -0,0 +1,13 @@
+//// [ExportAssignment8.ts]
+export = B;
+
+export class C {
+}
+
+//// [ExportAssignment8.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+exports.C = C;

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.js

@@ -0,0 +1,25 @@
+//// [ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts]
+module A {
+
+    class Point {
+        constructor(public x: number, public y: number) { }
+    }
+
+    export var UnitSquare : {
+        top: { left: Point, right: Point },
+        bottom: { left: Point, right: Point }
+    } = null;
+}
+
+//// [ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.js]
+var A;
+(function (A) {
+    var Point = (function () {
+        function Point(x, y) {
+            this.x = x;
+            this.y = y;
+        }
+        return Point;
+    })();
+    A.UnitSquare = null;
+})(A || (A = {}));

tests/baselines/reference/FunctionDeclaration12_es6.js

@@ -0,0 +1,6 @@
+//// [FunctionDeclaration12_es6.ts]
+var v = function * yield() { }
+
+//// [FunctionDeclaration12_es6.js]
+var v = , yield = function () {
+};

tests/baselines/reference/FunctionDeclaration5_es6.js

@@ -0,0 +1,8 @@
+//// [FunctionDeclaration5_es6.ts]
+function*foo(yield) {
+}
+
+//// [FunctionDeclaration5_es6.js]
+yield;
+{
+}

tests/baselines/reference/FunctionPropertyAssignments2_es6.js

@@ -0,0 +1,6 @@
+//// [FunctionPropertyAssignments2_es6.ts]
+var v = { *() { } }
+
+//// [FunctionPropertyAssignments2_es6.js]
+var v = { : function () {
+} };

tests/baselines/reference/FunctionPropertyAssignments3_es6.js

@@ -0,0 +1,6 @@
+//// [FunctionPropertyAssignments3_es6.ts]
+var v = { *{ } }
+
+//// [FunctionPropertyAssignments3_es6.js]
+var v = { : function () {
+} };

tests/baselines/reference/FunctionPropertyAssignments4_es6.js

@@ -0,0 +1,6 @@
+//// [FunctionPropertyAssignments4_es6.ts]
+var v = { * }
+
+//// [FunctionPropertyAssignments4_es6.js]
+var v = { : function () {
+} };

tests/baselines/reference/FunctionPropertyAssignments6_es6.js

@@ -0,0 +1,6 @@
+//// [FunctionPropertyAssignments6_es6.ts]
+var v = { *<T>() { } }
+
+//// [FunctionPropertyAssignments6_es6.js]
+var v = { : function () {
+} };

tests/baselines/reference/MemberFunctionDeclaration4_es6.js

@@ -0,0 +1,13 @@
+//// [MemberFunctionDeclaration4_es6.ts]
+class C {
+   *() { }
+}
+
+//// [MemberFunctionDeclaration4_es6.js]
+var C = (function () {
+    function C() {
+    }
+    C.prototype. = function () {
+    };
+    return C;
+})();

tests/baselines/reference/MemberFunctionDeclaration5_es6.js

@@ -0,0 +1,11 @@
+//// [MemberFunctionDeclaration5_es6.ts]
+class C {
+   *
+}
+
+//// [MemberFunctionDeclaration5_es6.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();

tests/baselines/reference/MemberFunctionDeclaration6_es6.js

@@ -0,0 +1,11 @@
+//// [MemberFunctionDeclaration6_es6.ts]
+class C {
+   *foo
+}
+
+//// [MemberFunctionDeclaration6_es6.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();

tests/baselines/reference/MemberFunctionDeclaration8_es6.js

@@ -0,0 +1,22 @@
+//// [MemberFunctionDeclaration8_es6.ts]
+class C {
+  foo() {
+    // Make sure we don't think of *bar as the start of a generator method.
+    if (a) # * bar;
+    return bar; 
+  }
+}
+
+//// [MemberFunctionDeclaration8_es6.js]
+var C = (function () {
+    function C() {
+    }
+    C.prototype.foo = function () {
+        // Make sure we don't think of *bar as the start of a generator method.
+        if (a)
+            ;
+         * bar;
+        return bar;
+    };
+    return C;
+})();

tests/baselines/reference/TemplateExpression1.js

@@ -0,0 +1,5 @@
+//// [TemplateExpression1.ts]
+var v = `foo ${ a 
+
+//// [TemplateExpression1.js]
+var v = "foo " + a;

tests/baselines/reference/TupleType4.js

@@ -0,0 +1,5 @@
+//// [TupleType4.ts]
+var v: [
+
+//// [TupleType4.js]
+var v;

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.js

@@ -0,0 +1,60 @@
+//// [tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.ts] ////
+
+//// [part1.ts]
+export module A {
+    export interface Point {
+        x: number;
+        y: number;
+    }
+
+    export module Utils {
+        export function mirror<T extends Point>(p: T) {
+            return { x: p.y, y: p.x };
+        }
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+}
+
+//// [part2.ts]
+export module A {
+    // collision with 'Origin' var in other part of merged module
+    export var Origin: Point = { x: 0, y: 0 };
+
+    export module Utils {
+        export class Plane {
+            constructor(public tl: Point, public br: Point) { }
+        }
+    }
+}
+
+
+//// [part1.js]
+var A;
+(function (A) {
+    var Utils;
+    (function (Utils) {
+        function mirror(p) {
+            return { x: p.y, y: p.x };
+        }
+        Utils.mirror = mirror;
+    })(Utils = A.Utils || (A.Utils = {}));
+    A.Origin = { x: 0, y: 0 };
+})(A = exports.A || (exports.A = {}));
+//// [part2.js]
+var A;
+(function (A) {
+    // collision with 'Origin' var in other part of merged module
+    A.Origin = { x: 0, y: 0 };
+    var Utils;
+    (function (Utils) {
+        var Plane = (function () {
+            function Plane(tl, br) {
+                this.tl = tl;
+                this.br = br;
+            }
+            return Plane;
+        })();
+        Utils.Plane = Plane;
+    })(Utils = A.Utils || (A.Utils = {}));
+})(A = exports.A || (exports.A = {}));

tests/baselines/reference/TypeArgumentList1.js

@@ -0,0 +1,5 @@
+//// [TypeArgumentList1.ts]
+Foo<A,B,\ C>(4, 5, 6);
+
+//// [TypeArgumentList1.js]
+Foo(4, 5, 6);

tests/baselines/reference/YieldExpression5_es6.js

@@ -0,0 +1,9 @@
+//// [YieldExpression5_es6.ts]
+function* foo() {
+  yield*
+}
+
+//// [YieldExpression5_es6.js]
+function foo() {
+    ;
+}

tests/baselines/reference/aliasErrors.js

@@ -0,0 +1,68 @@
+//// [aliasErrors.ts]
+module foo {    
+    export class Provide {
+    }
+    export module bar { export module baz {export class boo {}}}
+}
+
+import provide = foo;
+import booz = foo.bar.baz;
+import beez = foo.bar;
+
+import m = no;
+import m2 = no.mod;
+import n = 5;
+import o = "s";
+import q = null;
+import r = undefined;
+
+
+var p = new provide.Provide();
+
+function use() {
+    
+  beez.baz.boo;
+  var p1: provide.Provide; 
+  var p2: foo.Provide;
+  var p3:booz.bar;
+  var p22 = new provide.Provide();
+}
+
+
+
+//// [aliasErrors.js]
+var foo;
+(function (foo) {
+    var Provide = (function () {
+        function Provide() {
+        }
+        return Provide;
+    })();
+    foo.Provide = Provide;
+    var bar;
+    (function (bar) {
+        var baz;
+        (function (baz) {
+            var boo = (function () {
+                function boo() {
+                }
+                return boo;
+            })();
+            baz.boo = boo;
+        })(baz = bar.baz || (bar.baz = {}));
+    })(bar = foo.bar || (foo.bar = {}));
+})(foo || (foo = {}));
+var provide = foo;
+var booz = foo.bar.baz;
+var beez = foo.bar;
+5;
+"s";
+null;
+var p = new provide.Provide();
+function use() {
+    beez.baz.boo;
+    var p1;
+    var p2;
+    var p3;
+    var p22 = new provide.Provide();
+}

tests/baselines/reference/ambientDeclarationsExternal.js

@@ -0,0 +1,33 @@
+//// [tests/cases/conformance/ambient/ambientDeclarationsExternal.ts] ////
+
+//// [decls.ts]
+
+// Ambient external module with export assignment
+declare module 'equ' {
+    var x;
+    export = x;
+}
+
+declare module 'equ2' {
+    var x: number;
+}
+
+// Ambient external import declaration referencing ambient external module using top level module name
+//// [consumer.ts]
+/// <reference path="decls.ts" />
+import imp1 = require('equ');
+
+
+// Ambient external module members are always exported with or without export keyword when module lacks export assignment
+import imp3 = require('equ2');
+var n = imp3.x;
+var n: number;
+
+
+//// [decls.js]
+// Ambient external import declaration referencing ambient external module using top level module name 
+//// [consumer.js]
+// Ambient external module members are always exported with or without export keyword when module lacks export assignment
+var imp3 = require('equ2');
+var n = imp3.x;
+var n;

tests/baselines/reference/ambiguousGenericAssertion1.js

@@ -0,0 +1,15 @@
+//// [ambiguousGenericAssertion1.ts]
+function f<T>(x: T): T { return null; }
+var r = <T>(x: T) => x;
+var r2 = < <T>(x: T) => T>f; // valid
+var r3 = <<T>(x: T) => T>f; // ambiguous, appears to the parser as a << operation
+
+
+//// [ambiguousGenericAssertion1.js]
+function f(x) {
+    return null;
+}
+var r = function (x) { return x; };
+var r2 = f; // valid
+var r3 =  << T > (x), T;
+T > f; // ambiguous, appears to the parser as a << operation