Accept good (!??!) baseline changes

Author: weswigham

tests/baselines/reference/newOperatorConformance.errors.txt

@@ -0,0 +1,68 @@
+tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts(32,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'c1' must be of type 'T<unknown>', but here has type 'T<{}>'.
+
+
+==== tests/cases/conformance/expressions/newOperator/newOperatorConformance.ts (1 errors) ====
+    class C0 {
+    
+    }
+    class C1 {
+        constructor(n: number, s: string) { }
+    }
+    
+    class T<T> {
+        constructor(n?: T) { }
+    }
+    
+    var anyCtor: {
+        new (): any;
+    };
+    
+    var anyCtor1: {
+        new (n): any;
+    };
+    
+    interface nestedCtor {
+        new (): nestedCtor;
+    }
+    var nestedCtor: nestedCtor;
+    
+    // Construct expression with no parentheses for construct signature with 0 parameters
+    var a = new C0;
+    var a: C0;
+    
+    
+    // Generic construct expression with no parentheses
+    var c1 = new T;
+    var c1: T<{}>;
+        ~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'c1' must be of type 'T<unknown>', but here has type 'T<{}>'.
+    
+    // Construct expression where constructor is of type 'any' with no parentheses
+    var d = new anyCtor;
+    var d: any;
+    
+    // Construct expression where constructor is of type 'any' with > 1 arg
+    var d = new anyCtor1(undefined);
+    
+    // Construct expression of type where apparent type has a construct signature with 0 arguments
+    function newFn1<T extends { new (): number }>(s: T) {
+        var p = new s;
+        var p: number;
+    }
+    
+    // Construct expression of type where apparent type has a construct signature with 1 arguments
+    function newFn2<T extends { new (s: number): string}>(s: T) {
+        var p = new s(32);
+        var p: string;
+    }
+    
+    // Construct expression of void returning function
+    function fnVoid(): void { }
+    var t = new fnVoid();
+    var t: any;
+    
+    // Chained new expressions
+    var nested = new (new (new nestedCtor())())();
+    var n = new nested();
+    var n = new nested();
+    

tests/baselines/reference/newOperatorErrorCases.errors.txt

@@ -1,10 +1,11 @@
 tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS1005: ',' expected.
 tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(26,16): error TS2695: Left side of comma operator is unused and has no side effects.
+tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(30,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'c1' must be of type 'T<unknown>', but here has type 'T<{}>'.
 tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(31,23): error TS1005: '(' expected.
 tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(36,9): error TS2350: Only a void function can be called with the 'new' keyword.
 
 
-==== tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts (4 errors) ====
+==== tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts (5 errors) ====
     class C0 {
 
     }
@@ -39,6 +40,8 @@ tests/cases/conformance/expressions/newOperator/newOperatorErrorCases.ts(36,9):
     // Generic construct expression with no parentheses
     var c1 = new T;
     var c1: T<{}>;
+        ~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'c1' must be of type 'T<unknown>', but here has type 'T<{}>'.
     var c2 = new T<string>; // Parse error
                           ~
 !!! error TS1005: '(' expected.

tests/baselines/reference/wrappedAndRecursiveConstraints2.errors.txt

@@ -0,0 +1,12 @@
+tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursiveConstraints2.ts(6,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'c' must be of type 'C<number>', but here has type 'C<C<string>>'.
+
+
+==== tests/cases/conformance/types/typeParameters/typeArgumentLists/wrappedAndRecursiveConstraints2.ts (1 errors) ====
+    class C<T extends C<T>> { // error
+        constructor(x: T) { }
+    }
+    
+    var c = new C(1);
+    var c = new C(new C('')); // error
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'c' must be of type 'C<number>', but here has type 'C<C<string>>'.