From 3e572f5b71dc38125f3d01114e4f7efc724ca00c Mon Sep 17 00:00:00 2001
From: SaschaNaz <saschanaz@outlook.com>
Date: Fri, 28 Aug 2015 00:00:34 +0900
Subject: [PATCH 01/17] change some template literal tests

---
 tests/cases/fourslash/formatTemplateLiteral.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/cases/fourslash/formatTemplateLiteral.ts b/tests/cases/fourslash/formatTemplateLiteral.ts
index 29e58160cc1..007ebb344f7 100644
--- a/tests/cases/fourslash/formatTemplateLiteral.ts
+++ b/tests/cases/fourslash/formatTemplateLiteral.ts
@@ -2,8 +2,8 @@
 ////var x = `sadasdasdasdasfegsfd
 /////*1*/rasdesgeryt35t35y35 e4 ergt er 35t 3535 `;
 ////var y = `1${2}/*2*/3`;
-////let z=    `foo`/*3*/
-////let w=  `bar${3}`/*4*/
+////String.raw`foo`/*3*/
+////String.raw  `bar${3}`/*4*/
 ////String.raw
 //// `template`/*5*/
 
@@ -18,10 +18,10 @@ verify.currentLineContentIs("3`;")
 
 goTo.marker("3");
 edit.insert(";");
-verify.currentLineContentIs("let z = `foo`;");
+verify.currentLineContentIs("String.raw `foo`;");
 goTo.marker("4");
 edit.insert(";");
-verify.currentLineContentIs("let w = `bar${3}`;");
+verify.currentLineContentIs("String.raw `bar${3}`;");
 
 goTo.marker("5");
 edit.insert(";");

From 070353538158b62c7b877cc2db1be4ecfa5e6441 Mon Sep 17 00:00:00 2001
From: SaschaNaz <saschanaz@outlook.com>
Date: Fri, 28 Aug 2015 23:12:30 +0900
Subject: [PATCH 02/17] Do not replace but do extend

---
 tests/cases/fourslash/formatTemplateLiteral.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/tests/cases/fourslash/formatTemplateLiteral.ts b/tests/cases/fourslash/formatTemplateLiteral.ts
index 007ebb344f7..45ad17c4c95 100644
--- a/tests/cases/fourslash/formatTemplateLiteral.ts
+++ b/tests/cases/fourslash/formatTemplateLiteral.ts
@@ -2,10 +2,12 @@
 ////var x = `sadasdasdasdasfegsfd
 /////*1*/rasdesgeryt35t35y35 e4 ergt er 35t 3535 `;
 ////var y = `1${2}/*2*/3`;
-////String.raw`foo`/*3*/
-////String.raw  `bar${3}`/*4*/
+////let z=    `foo`/*3*/
+////let w=  `bar${3}`/*4*/
 ////String.raw
 //// `template`/*5*/
+////String.raw`foo`/*6*/
+////String.raw  `bar${3}`/*7*/
 
 
 goTo.marker("1");
@@ -18,11 +20,17 @@ verify.currentLineContentIs("3`;")
 
 goTo.marker("3");
 edit.insert(";");
-verify.currentLineContentIs("String.raw `foo`;");
+verify.currentLineContentIs("let z = `foo`;"); 
 goTo.marker("4");
 edit.insert(";");
-verify.currentLineContentIs("String.raw `bar${3}`;");
+verify.currentLineContentIs("let w = `bar${3}`;"); 
 
 goTo.marker("5");
 edit.insert(";");
-verify.currentLineContentIs("    `template`;");
\ No newline at end of file
+verify.currentLineContentIs("    `template`;");
+goTo.marker("6");
+edit.insert(";");
+verify.currentLineContentIs("String.raw `foo`;");
+goTo.marker("7");
+edit.insert(";");
+verify.currentLineContentIs("String.raw `bar${3}`;");
\ No newline at end of file

From 019993ea8b926c71c89b985c166f28c141100070 Mon Sep 17 00:00:00 2001
From: SaschaNaz <saschanaz@outlook.com>
Date: Fri, 28 Aug 2015 23:13:15 +0900
Subject: [PATCH 03/17] remove spaces

---
 tests/cases/fourslash/formatTemplateLiteral.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/cases/fourslash/formatTemplateLiteral.ts b/tests/cases/fourslash/formatTemplateLiteral.ts
index 45ad17c4c95..6d1352fcf0d 100644
--- a/tests/cases/fourslash/formatTemplateLiteral.ts
+++ b/tests/cases/fourslash/formatTemplateLiteral.ts
@@ -20,10 +20,10 @@ verify.currentLineContentIs("3`;")
 
 goTo.marker("3");
 edit.insert(";");
-verify.currentLineContentIs("let z = `foo`;"); 
+verify.currentLineContentIs("let z = `foo`;");
 goTo.marker("4");
 edit.insert(";");
-verify.currentLineContentIs("let w = `bar${3}`;"); 
+verify.currentLineContentIs("let w = `bar${3}`;");
 
 goTo.marker("5");
 edit.insert(";");

From 8028ab56c59f1d1cebcea85602b828116dfcc1b4 Mon Sep 17 00:00:00 2001
From: Dick van den Brink <d_vandenbrink@outlook.com>
Date: Fri, 28 Aug 2015 20:05:19 +0200
Subject: [PATCH 04/17] Fix occurrences on `this` in class expressions Fix
 #4479

---
 src/services/services.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/services/services.ts b/src/services/services.ts
index 4358c9d58a9..752fb93cd00 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -5885,6 +5885,7 @@ namespace ts {
                                     result.push(getReferenceEntryFromNode(node));
                                 }
                                 break;
+                            case SyntaxKind.ClassExpression:
                             case SyntaxKind.ClassDeclaration:
                                 // Make sure the container belongs to the same class
                                 // and has the appropriate static modifier from the original container.

From 1f8de043a181cdbce3d58f949c4f44c2f99e59e8 Mon Sep 17 00:00:00 2001
From: Dick van den Brink <d_vandenbrink@outlook.com>
Date: Fri, 28 Aug 2015 20:05:54 +0200
Subject: [PATCH 05/17] Added tests for getOccurrences on `this` in class
 expressions

---
 ...getOccurrencesClassExpressionStaticThis.ts | 56 +++++++++++++++++++
 .../getOccurrencesClassExpressionThis.ts      | 54 ++++++++++++++++++
 2 files changed, 110 insertions(+)
 create mode 100644 tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
 create mode 100644 tests/cases/fourslash/getOccurrencesClassExpressionThis.ts

diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts b/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
new file mode 100644
index 00000000000..5444ab9acdd
--- /dev/null
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
@@ -0,0 +1,56 @@
+/// <reference path='fourslash.ts' />
+
+////var x = class C {
+////    public x;
+////    public y;
+////    public z;
+////    public staticX;
+////    constructor() {
+////        this;
+////        this.x;
+////        this.y;
+////        this.z;
+////    }
+////    foo() {
+////        this;
+////        () => this;
+////        () => {
+////            if (this) {
+////                this;
+////            }
+////        }
+////        function inside() {
+////            this;
+////            (function (_) {
+////                this;
+////            })(this);
+////        }
+////        return this.x;
+////    }
+////
+////    static bar() {
+////        [|this|];
+////        [|this|].staticX;
+////        () => [|this|];
+////        () => {
+////            if ([|this|]) {
+////                [|this|];
+////            }
+////        }
+////        function inside() {
+////            this;
+////            (function (_) {
+////                this;
+////            })(this);
+////        }
+////    }
+////}
+
+const ranges = test.ranges();
+for (let r of ranges) {
+    goTo.position(r.start);
+
+    for (let range of ranges) {
+        verify.occurrencesAtPositionContains(range, false);
+    }
+}
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts b/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts
new file mode 100644
index 00000000000..ed8f8cb1d0e
--- /dev/null
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts
@@ -0,0 +1,54 @@
+/// <reference path='fourslash.ts' />
+
+////var x = class C {
+////    public x;
+////    public y;
+////    public z;
+////    constructor() {
+////        [|this|];
+////        [|this|].x;
+////        [|this|].y;
+////        [|this|].z;
+////    }
+////    foo() {
+////        [|this|];
+////        () => [|this|];
+////        () => {
+////            if ([|this|]) {
+////                [|this|];
+////            }
+////        }
+////        function inside() {
+////            this;
+////            (function (_) {
+////                this;
+////            })(this);
+////        }
+////        return [|this|].x;
+////    }
+////
+////    static bar() {
+////        this;
+////        () => this;
+////        () => {
+////            if (this) {
+////                this;
+////            }
+////        }
+////        function inside() {
+////            this;
+////            (function (_) {
+////                this;
+////            })(this);
+////        }
+////    }
+////}
+
+const ranges = test.ranges();
+for (let r of ranges) {
+    goTo.position(r.start);
+
+    for (let range of ranges) {
+        verify.occurrencesAtPositionContains(range, false);
+    }
+}

From d8d7fb96b5aa4a1a9c9c8d2932c280d7cc5d78e3 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 28 Aug 2015 14:50:58 -0700
Subject: [PATCH 06/17] Restoring union type subtype reduction

---
 src/compiler/checker.ts | 138 +++++++++++++---------------------------
 1 file changed, 44 insertions(+), 94 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 35c12dedc37..2fdeded96cf 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3119,7 +3119,7 @@ namespace ts {
         }
 
         function resolveTupleTypeMembers(type: TupleType) {
-            let arrayType = resolveStructuredTypeMembers(createArrayType(getUnionType(type.elementTypes, /*noDeduplication*/ true)));
+            let arrayType = resolveStructuredTypeMembers(createArrayType(getUnionType(type.elementTypes, /*noSubtypeReduction*/ true)));
             let members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
@@ -3451,29 +3451,6 @@ namespace ts {
             return undefined;
         }
 
-        // Check if a property with the given name is known anywhere in the given type. In an object
-        // type, a property is considered known if the object type is empty, if it has any index
-        // signatures, or if the property is actually declared in the type. In a union or intersection
-        // type, a property is considered known if it is known in any constituent type.
-        function isKnownProperty(type: Type, name: string): boolean {
-            if (type.flags & TypeFlags.ObjectType && type !== globalObjectType) {
-                const resolved = resolveStructuredTypeMembers(type);
-                return !!(resolved.properties.length === 0 ||
-                    resolved.stringIndexType ||
-                    resolved.numberIndexType ||
-                    getPropertyOfType(type, name));
-            }
-            if (type.flags & TypeFlags.UnionOrIntersection) {
-                for (let t of (<UnionOrIntersectionType>type).types) {
-                    if (isKnownProperty(t, name)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-            return true;
-        }
-
         function getSignaturesOfStructuredType(type: Type, kind: SignatureKind): Signature[] {
             if (type.flags & TypeFlags.StructuredType) {
                 let resolved = resolveStructuredTypeMembers(<ObjectType>type);
@@ -4103,73 +4080,20 @@ namespace ts {
             }
         }
 
-        function isObjectLiteralTypeDuplicateOf(source: ObjectType, target: ObjectType): boolean {
-            let sourceProperties = getPropertiesOfObjectType(source);
-            let targetProperties = getPropertiesOfObjectType(target);
-            if (sourceProperties.length !== targetProperties.length) {
-                return false;
-            }
-            for (let sourceProp of sourceProperties) {
-                let targetProp = getPropertyOfObjectType(target, sourceProp.name);
-                if (!targetProp ||
-                    getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected) ||
-                    !isTypeDuplicateOf(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp))) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        function isTupleTypeDuplicateOf(source: TupleType, target: TupleType): boolean {
-            let sourceTypes = source.elementTypes;
-            let targetTypes = target.elementTypes;
-            if (sourceTypes.length !== targetTypes.length) {
-                return false;
-            }
-            for (var i = 0; i < sourceTypes.length; i++) {
-                if (!isTypeDuplicateOf(sourceTypes[i], targetTypes[i])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        // Returns true if the source type is a duplicate of the target type. A source type is a duplicate of
-        // a target type if the the two are identical, with the exception that the source type may have null or
-        // undefined in places where the target type doesn't. This is by design an asymmetric relationship.
-        function isTypeDuplicateOf(source: Type, target: Type): boolean {
-            if (source === target) {
-                return true;
-            }
-            if (source.flags & TypeFlags.Undefined || source.flags & TypeFlags.Null && !(target.flags & TypeFlags.Undefined)) {
-                return true;
-            }
-            if (source.flags & TypeFlags.ObjectLiteral && target.flags & TypeFlags.ObjectType) {
-                return isObjectLiteralTypeDuplicateOf(<ObjectType>source, <ObjectType>target);
-            }
-            if (isArrayType(source) && isArrayType(target)) {
-                return isTypeDuplicateOf((<TypeReference>source).typeArguments[0], (<TypeReference>target).typeArguments[0]);
-            }
-            if (isTupleType(source) && isTupleType(target)) {
-                return isTupleTypeDuplicateOf(<TupleType>source, <TupleType>target);
-            }
-            return isTypeIdenticalTo(source, target);
-        }
-
-        function isTypeDuplicateOfSomeType(candidate: Type, types: Type[]): boolean {
-            for (let type of types) {
-                if (candidate !== type && isTypeDuplicateOf(candidate, type)) {
+        function isSubtypeOfAny(candidate: Type, types: Type[]): boolean {
+            for (var i = 0, len = types.length; i < len; i++) {
+                if (candidate !== types[i] && isTypeSubtypeOf(candidate, types[i])) {
                     return true;
                 }
             }
             return false;
         }
 
-        function removeDuplicateTypes(types: Type[]) {
-            let i = types.length;
+        function removeSubtypes(types: Type[]) {
+            var i = types.length;
             while (i > 0) {
                 i--;
-                if (isTypeDuplicateOfSomeType(types[i], types)) {
+                if (isSubtypeOfAny(types[i], types)) {
                     types.splice(i, 1);
                 }
             }
@@ -4194,12 +4118,14 @@ namespace ts {
             }
         }
 
-        // We always deduplicate the constituent type set based on object identity, but we'll also deduplicate
-        // based on the structure of the types unless the noDeduplication flag is true, which is the case when
-        // creating a union type from a type node and when instantiating a union type. In both of those cases,
-        // structural deduplication has to be deferred to properly support recursive union types. For example,
-        // a type of the form "type Item = string | (() => Item)" cannot be deduplicated during its declaration.
-        function getUnionType(types: Type[], noDeduplication?: boolean): Type {
+        // We reduce the constituent type set to only include types that aren't subtypes of other types, unless
+        // the noSubtypeReduction flag is specified, in which case we perform a simple deduplication based on
+        // object identity. Subtype reduction is possible only when union types are known not to circularly
+        // reference themselves (as is the case with union types created by expression constructs such as array
+        // literals and the || and ?: operators). Named types can circularly reference themselves and therefore
+        // cannot be deduplicated during their declaration. For example, "type Item = string | (() => Item" is
+        // a named type that circularly references itself.
+        function getUnionType(types: Type[], noSubtypeReduction?: boolean): Type {
             if (types.length === 0) {
                 return emptyObjectType;
             }
@@ -4208,12 +4134,12 @@ namespace ts {
             if (containsTypeAny(typeSet)) {
                 return anyType;
             }
-            if (noDeduplication) {
+            if (noSubtypeReduction) {
                 removeAllButLast(typeSet, undefinedType);
                 removeAllButLast(typeSet, nullType);
             }
             else {
-                removeDuplicateTypes(typeSet);
+                removeSubtypes(typeSet);
             }
             if (typeSet.length === 1) {
                 return typeSet[0];
@@ -4230,7 +4156,7 @@ namespace ts {
         function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noDeduplication*/ true);
+                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
             }
             return links.resolvedType;
         }
@@ -4526,7 +4452,7 @@ namespace ts {
                     return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
                 }
                 if (type.flags & TypeFlags.Union) {
-                    return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*noDeduplication*/ true);
+                    return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*noSubtypeReduction*/ true);
                 }
                 if (type.flags & TypeFlags.Intersection) {
                     return getIntersectionType(instantiateList((<IntersectionType>type).types, mapper, instantiateType));
@@ -4813,6 +4739,30 @@ namespace ts {
                 return Ternary.False;
             }
 
+            // Check if a property with the given name is known anywhere in the given type. In an object type, a property
+            // is considered known if the object type is empty and the check is for assignability, if the object type has
+            // index signatures, or if the property is actually declared in the object type. In a union or intersection
+            // type, a property is considered known if it is known in any constituent type.
+            function isKnownProperty(type: Type, name: string): boolean {
+                if (type.flags & TypeFlags.ObjectType) {
+                    const resolved = resolveStructuredTypeMembers(type);
+                    if (relation === assignableRelation && (type === globalObjectType || resolved.properties.length === 0) ||
+                        resolved.stringIndexType || resolved.numberIndexType || getPropertyOfType(type, name)) {
+                        return true;
+                    }
+                    return false;
+                }
+                if (type.flags & TypeFlags.UnionOrIntersection) {
+                    for (let t of (<UnionOrIntersectionType>type).types) {
+                        if (isKnownProperty(t, name)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return true;
+            }
+
             function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
                 for (let prop of getPropertiesOfObjectType(source)) {
                     if (!isKnownProperty(target, prop.name)) {
@@ -5594,7 +5544,7 @@ namespace ts {
                     return getWidenedTypeOfObjectLiteral(type);
                 }
                 if (type.flags & TypeFlags.Union) {
-                    return getUnionType(map((<UnionType>type).types, getWidenedType));
+                    return getUnionType(map((<UnionType>type).types, getWidenedType), /*noSubtypeReduction*/ true);
                 }
                 if (isArrayType(type)) {
                     return createArrayType(getWidenedType((<TypeReference>type).typeArguments[0]));

From 00e7c46ea90e53174efe5e05e144ac998949cdb4 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 28 Aug 2015 15:59:37 -0700
Subject: [PATCH 07/17] Fixing fourslash tests

---
 .../cases/fourslash/bestCommonTypeObjectLiterals1.ts |  2 +-
 .../fourslash/completionEntryForUnionProperty2.ts    |  6 +++---
 .../fourslash/contextualTypingOfArrayLiterals1.ts    | 12 ++----------
 3 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
index d7ccbe73f33..5a8f661789c 100644
--- a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
+++ b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
@@ -24,7 +24,7 @@ goTo.marker('1');
 verify.quickInfoIs('var c: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('2');
-verify.quickInfoIs('var c1: ({\n    name: string;\n    age: number;\n} | {\n    name: string;\n    age: number;\n    dob: Date;\n})[]');
+verify.quickInfoIs('var c1: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('3');
 verify.quickInfoIs('var c2: ({\n\
diff --git a/tests/cases/fourslash/completionEntryForUnionProperty2.ts b/tests/cases/fourslash/completionEntryForUnionProperty2.ts
index aa5bc40b5e3..c2d7bc406a5 100644
--- a/tests/cases/fourslash/completionEntryForUnionProperty2.ts
+++ b/tests/cases/fourslash/completionEntryForUnionProperty2.ts
@@ -1,12 +1,12 @@
 ///<reference path="fourslash.ts" />
 
 ////interface One {
-////    commonProperty: number;
+////    commonProperty: string;
 ////    commonFunction(): number;
 ////}
 ////
 ////interface Two {
-////    commonProperty: string
+////    commonProperty: number;
 ////    commonFunction(): number;
 ////}
 ////
@@ -16,5 +16,5 @@
 
 goTo.marker();
 verify.memberListContains("toString", "(method) toString(): string");
-verify.memberListContains("valueOf", "(method) valueOf(): number | string");
+verify.memberListContains("valueOf", "(method) valueOf(): string | number");
 verify.memberListCount(2);
\ No newline at end of file
diff --git a/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts b/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
index fb77ecdce65..dbd7aeb5f01 100644
--- a/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
+++ b/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
@@ -43,21 +43,13 @@ goTo.marker('4');
 verify.quickInfoIs('var r4: C');
 
 goTo.marker('5');
-verify.quickInfoIs('var x5: ({\n\
+verify.quickInfoIs('var x5: {\n\
     name: string;\n\
     age: number;\n\
-} | {\n\
-    name: string;\n\
-    age: number;\n\
-    dob: Date;\n\
-})[]');
+}[]');
 
 goTo.marker('6');
 verify.quickInfoIs('var r5: {\n\
     name: string;\n\
     age: number;\n\
-} | {\n\
-    name: string;\n\
-    age: number;\n\
-    dob: Date;\n\
 }');

From 49bb2bbc1574e9d8a81e29bf74572d869bddc48c Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 28 Aug 2015 16:00:14 -0700
Subject: [PATCH 08/17] Accepting new baselines

---
 .../reference/arrayBestCommonTypes.types      |  44 +++----
 ...ayLiteralWithMultipleBestCommonTypes.types |   8 +-
 .../arrayLiteralsWithRecursiveGenerics.types  |   4 +-
 .../arrayOfFunctionTypes3.errors.txt          |  35 ------
 .../reference/arrayOfFunctionTypes3.symbols   |  93 ++++++++++++++
 .../reference/arrayOfFunctionTypes3.types     | 116 ++++++++++++++++++
 ...stCommonTypeOfConditionalExpressions.types |  18 +--
 ...bestCommonTypeWithOptionalProperties.types |  24 ++--
 .../conditionalOperatorWithIdenticalBCT.types |  32 ++---
 .../contextualTypingArrayOfLambdas.types      |   4 +-
 ...orStatementsMultipleInvalidDecl.errors.txt |   4 +-
 .../reference/functionImplementations.types   |   4 +-
 .../reference/generatedContextualTyping.types |  32 ++---
 .../heterogeneousArrayLiterals.types          |  88 ++++++-------
 ...lidMultipleVariableDeclarations.errors.txt |   4 +-
 .../logicalOrOperatorWithEveryType.types      |   8 +-
 .../logicalOrOperatorWithTypeParameters.types |   4 +-
 ...ConstrainsPropertyDeclarations2.errors.txt |   8 +-
 .../objectLiteralIndexerErrors.errors.txt     |   4 +-
 .../reference/objectLiteralIndexers.types     |   2 +-
 .../parenthesizedContexualTyping1.types       |  18 +--
 .../parenthesizedContexualTyping2.types       |  18 +--
 ...rConstrainsPropertyDeclarations.errors.txt |   8 +-
 ...ConstrainsPropertyDeclarations2.errors.txt |  14 +--
 .../subtypingWithCallSignatures2.types        | 112 ++++++++---------
 .../subtypingWithCallSignatures3.types        |  56 ++++-----
 .../subtypingWithCallSignatures4.types        |  32 ++---
 .../subtypingWithConstructSignatures2.types   | 104 ++++++++--------
 .../subtypingWithConstructSignatures3.types   |  56 ++++-----
 .../subtypingWithConstructSignatures4.types   |  32 ++---
 ...ubtypingWithObjectMembersOptionality.types |   8 +-
 tests/baselines/reference/symbolType11.types  |   2 +-
 .../typeGuardsInConditionalExpression.types   |   4 +-
 .../reference/typeGuardsInIfStatement.types   |  12 +-
 ...GuardsInRightOperandOfAndAndOperator.types |   8 +-
 ...peGuardsInRightOperandOfOrOrOperator.types |   8 +-
 .../baselines/reference/underscoreTest1.types |   4 +-
 .../reference/unionTypeFromArrayLiteral.types |   8 +-
 .../reference/unionTypeReduction.types        |   6 +-
 ...onTypeWithRecursiveSubtypeReduction1.types |   4 +-
 40 files changed, 611 insertions(+), 439 deletions(-)
 delete mode 100644 tests/baselines/reference/arrayOfFunctionTypes3.errors.txt
 create mode 100644 tests/baselines/reference/arrayOfFunctionTypes3.symbols
 create mode 100644 tests/baselines/reference/arrayOfFunctionTypes3.types

diff --git a/tests/baselines/reference/arrayBestCommonTypes.types b/tests/baselines/reference/arrayBestCommonTypes.types
index 9b05aff5ac6..20f36e5c459 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.types
+++ b/tests/baselines/reference/arrayBestCommonTypes.types
@@ -294,8 +294,8 @@ module EmptyTypes {
 
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
->a1 : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
->[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
+>a1 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : { x: any; y: string; }[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -313,8 +313,8 @@ module EmptyTypes {
 >'a' : string
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
->a2 : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
->[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
+>a2 : { x: any; y: string; }[]
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
 >{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
@@ -332,8 +332,8 @@ module EmptyTypes {
 >'a' : string
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
->a3 : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
->[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
+>a3 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -639,7 +639,7 @@ module NonEmptyTypes {
 >x : number
 >y : base
 >base : base
->[{ x: 7, y: new derived() }, { x: 5, y: new base() }] : ({ x: number; y: derived; } | { x: number; y: base; })[]
+>[{ x: 7, y: new derived() }, { x: 5, y: new base() }] : { x: number; y: base; }[]
 >{ x: 7, y: new derived() } : { x: number; y: derived; }
 >x : number
 >7 : number
@@ -658,7 +658,7 @@ module NonEmptyTypes {
 >x : boolean
 >y : base
 >base : base
->[{ x: true, y: new derived() }, { x: false, y: new base() }] : ({ x: boolean; y: derived; } | { x: boolean; y: base; })[]
+>[{ x: true, y: new derived() }, { x: false, y: new base() }] : { x: boolean; y: base; }[]
 >{ x: true, y: new derived() } : { x: boolean; y: derived; }
 >x : boolean
 >true : boolean
@@ -697,8 +697,8 @@ module NonEmptyTypes {
 
             // Order matters here so test all the variants
             var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
->a1 : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
->[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
+>a1 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : { x: any; y: string; }[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -716,8 +716,8 @@ module NonEmptyTypes {
 >'a' : string
 
             var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
->a2 : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
->[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
+>a2 : { x: any; y: string; }[]
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
 >{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
@@ -735,8 +735,8 @@ module NonEmptyTypes {
 >'a' : string
 
             var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
->a3 : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
->[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
+>a3 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -769,29 +769,29 @@ module NonEmptyTypes {
 >base2 : typeof base2
 
             var b1 = [baseObj, base2Obj, ifaceObj];
->b1 : (base | base2 | iface)[]
->[baseObj, base2Obj, ifaceObj] : (base | base2 | iface)[]
+>b1 : iface[]
+>[baseObj, base2Obj, ifaceObj] : iface[]
 >baseObj : base
 >base2Obj : base2
 >ifaceObj : iface
 
             var b2 = [base2Obj, baseObj, ifaceObj];
->b2 : (base2 | base | iface)[]
->[base2Obj, baseObj, ifaceObj] : (base2 | base | iface)[]
+>b2 : iface[]
+>[base2Obj, baseObj, ifaceObj] : iface[]
 >base2Obj : base2
 >baseObj : base
 >ifaceObj : iface
 
             var b3 = [baseObj, ifaceObj, base2Obj];
->b3 : (base | iface | base2)[]
->[baseObj, ifaceObj, base2Obj] : (base | iface | base2)[]
+>b3 : iface[]
+>[baseObj, ifaceObj, base2Obj] : iface[]
 >baseObj : base
 >ifaceObj : iface
 >base2Obj : base2
 
             var b4 = [ifaceObj, baseObj, base2Obj];
->b4 : (iface | base | base2)[]
->[ifaceObj, baseObj, base2Obj] : (iface | base | base2)[]
+>b4 : iface[]
+>[ifaceObj, baseObj, base2Obj] : iface[]
 >ifaceObj : iface
 >baseObj : base
 >base2Obj : base2
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
index 5b5a1be6b8a..1bbb6c41e8a 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
@@ -36,8 +36,8 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 >c : { x: number; a?: number; }
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
->ds : (((x: Object) => number) | ((x: string) => number))[]
->[(x: Object) => 1, (x: string) => 2] : (((x: Object) => number) | ((x: string) => number))[]
+>ds : ((x: Object) => number)[]
+>[(x: Object) => 1, (x: string) => 2] : ((x: Object) => number)[]
 >(x: Object) => 1 : (x: Object) => number
 >x : Object
 >Object : Object
@@ -47,8 +47,8 @@ var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >2 : number
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
->es : (((x: string) => number) | ((x: Object) => number))[]
->[(x: string) => 2, (x: Object) => 1] : (((x: string) => number) | ((x: Object) => number))[]
+>es : ((x: string) => number)[]
+>[(x: string) => 2, (x: Object) => 1] : ((x: string) => number)[]
 >(x: string) => 2 : (x: string) => number
 >x : string
 >2 : number
diff --git a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
index b7224fe91c4..9cdbe0a0a61 100644
--- a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
+++ b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
@@ -77,8 +77,8 @@ var myDerivedList: DerivedList<number>;
 >DerivedList : DerivedList<U>
 
 var as = [list, myDerivedList]; // List<number>[]
->as : (List<number> | DerivedList<number>)[]
->[list, myDerivedList] : (List<number> | DerivedList<number>)[]
+>as : List<number>[]
+>[list, myDerivedList] : List<number>[]
 >list : List<number>
 >myDerivedList : DerivedList<number>
 
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.errors.txt b/tests/baselines/reference/arrayOfFunctionTypes3.errors.txt
deleted file mode 100644
index 499d6bca387..00000000000
--- a/tests/baselines/reference/arrayOfFunctionTypes3.errors.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(17,13): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
-tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(26,10): error TS2349: Cannot invoke an expression whose type lacks a call signature.
-
-
-==== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts (2 errors) ====
-    // valid uses of arrays of function types
-    
-    var x = [() => 1, () => { }];
-    var r2 = x[0]();
-    
-    class C {
-        foo: string;
-    }
-    var y = [C, C];
-    var r3 = new y[0]();
-    
-    var a: { (x: number): number; (x: string): string; };
-    var b: { (x: number): number; (x: string): string; };
-    var c: { (x: number): number; (x: any): any; };
-    var z = [a, b, c];
-    var r4 = z[0];
-    var r5 = r4(''); // any not string
-                ~~
-!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
-    var r5b = r4(1);
-    
-    var a2: { <T>(x: T): number; (x: string): string;};
-    var b2: { <T>(x: T): number; (x: string): string; };
-    var c2: { (x: number): number; <T>(x: T): any; };
-    
-    var z2 = [a2, b2, c2];
-    var r6 = z2[0];
-    var r7 = r6(''); // any not string
-             ~~~~~~
-!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.symbols b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
new file mode 100644
index 00000000000..d26effeb5b7
--- /dev/null
+++ b/tests/baselines/reference/arrayOfFunctionTypes3.symbols
@@ -0,0 +1,93 @@
+=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts ===
+// valid uses of arrays of function types
+
+var x = [() => 1, () => { }];
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
+
+var r2 = x[0]();
+>r2 : Symbol(r2, Decl(arrayOfFunctionTypes3.ts, 3, 3))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
+
+class C {
+>C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
+
+    foo: string;
+>foo : Symbol(foo, Decl(arrayOfFunctionTypes3.ts, 5, 9))
+}
+var y = [C, C];
+>y : Symbol(y, Decl(arrayOfFunctionTypes3.ts, 8, 3))
+>C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
+>C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
+
+var r3 = new y[0]();
+>r3 : Symbol(r3, Decl(arrayOfFunctionTypes3.ts, 9, 3))
+>y : Symbol(y, Decl(arrayOfFunctionTypes3.ts, 8, 3))
+
+var a: { (x: number): number; (x: string): string; };
+>a : Symbol(a, Decl(arrayOfFunctionTypes3.ts, 11, 3))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 11, 10))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 11, 31))
+
+var b: { (x: number): number; (x: string): string; };
+>b : Symbol(b, Decl(arrayOfFunctionTypes3.ts, 12, 3))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 12, 10))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 12, 31))
+
+var c: { (x: number): number; (x: any): any; };
+>c : Symbol(c, Decl(arrayOfFunctionTypes3.ts, 13, 3))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 13, 10))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 13, 31))
+
+var z = [a, b, c];
+>z : Symbol(z, Decl(arrayOfFunctionTypes3.ts, 14, 3))
+>a : Symbol(a, Decl(arrayOfFunctionTypes3.ts, 11, 3))
+>b : Symbol(b, Decl(arrayOfFunctionTypes3.ts, 12, 3))
+>c : Symbol(c, Decl(arrayOfFunctionTypes3.ts, 13, 3))
+
+var r4 = z[0];
+>r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
+>z : Symbol(z, Decl(arrayOfFunctionTypes3.ts, 14, 3))
+
+var r5 = r4(''); // any not string
+>r5 : Symbol(r5, Decl(arrayOfFunctionTypes3.ts, 16, 3))
+>r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
+
+var r5b = r4(1);
+>r5b : Symbol(r5b, Decl(arrayOfFunctionTypes3.ts, 17, 3))
+>r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
+
+var a2: { <T>(x: T): number; (x: string): string;};
+>a2 : Symbol(a2, Decl(arrayOfFunctionTypes3.ts, 19, 3))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 19, 11))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 19, 14))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 19, 11))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 19, 30))
+
+var b2: { <T>(x: T): number; (x: string): string; };
+>b2 : Symbol(b2, Decl(arrayOfFunctionTypes3.ts, 20, 3))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 20, 11))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 20, 14))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 20, 11))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 20, 30))
+
+var c2: { (x: number): number; <T>(x: T): any; };
+>c2 : Symbol(c2, Decl(arrayOfFunctionTypes3.ts, 21, 3))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 21, 11))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 21, 32))
+>x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 21, 35))
+>T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 21, 32))
+
+var z2 = [a2, b2, c2];
+>z2 : Symbol(z2, Decl(arrayOfFunctionTypes3.ts, 23, 3))
+>a2 : Symbol(a2, Decl(arrayOfFunctionTypes3.ts, 19, 3))
+>b2 : Symbol(b2, Decl(arrayOfFunctionTypes3.ts, 20, 3))
+>c2 : Symbol(c2, Decl(arrayOfFunctionTypes3.ts, 21, 3))
+
+var r6 = z2[0];
+>r6 : Symbol(r6, Decl(arrayOfFunctionTypes3.ts, 24, 3))
+>z2 : Symbol(z2, Decl(arrayOfFunctionTypes3.ts, 23, 3))
+
+var r7 = r6(''); // any not string
+>r7 : Symbol(r7, Decl(arrayOfFunctionTypes3.ts, 25, 3))
+>r6 : Symbol(r6, Decl(arrayOfFunctionTypes3.ts, 24, 3))
+
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.types b/tests/baselines/reference/arrayOfFunctionTypes3.types
new file mode 100644
index 00000000000..0ed92991ed0
--- /dev/null
+++ b/tests/baselines/reference/arrayOfFunctionTypes3.types
@@ -0,0 +1,116 @@
+=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts ===
+// valid uses of arrays of function types
+
+var x = [() => 1, () => { }];
+>x : (() => void)[]
+>[() => 1, () => { }] : (() => void)[]
+>() => 1 : () => number
+>1 : number
+>() => { } : () => void
+
+var r2 = x[0]();
+>r2 : void
+>x[0]() : void
+>x[0] : () => void
+>x : (() => void)[]
+>0 : number
+
+class C {
+>C : C
+
+    foo: string;
+>foo : string
+}
+var y = [C, C];
+>y : typeof C[]
+>[C, C] : typeof C[]
+>C : typeof C
+>C : typeof C
+
+var r3 = new y[0]();
+>r3 : C
+>new y[0]() : C
+>y[0] : typeof C
+>y : typeof C[]
+>0 : number
+
+var a: { (x: number): number; (x: string): string; };
+>a : { (x: number): number; (x: string): string; }
+>x : number
+>x : string
+
+var b: { (x: number): number; (x: string): string; };
+>b : { (x: number): number; (x: string): string; }
+>x : number
+>x : string
+
+var c: { (x: number): number; (x: any): any; };
+>c : { (x: number): number; (x: any): any; }
+>x : number
+>x : any
+
+var z = [a, b, c];
+>z : { (x: number): number; (x: any): any; }[]
+>[a, b, c] : { (x: number): number; (x: any): any; }[]
+>a : { (x: number): number; (x: string): string; }
+>b : { (x: number): number; (x: string): string; }
+>c : { (x: number): number; (x: any): any; }
+
+var r4 = z[0];
+>r4 : { (x: number): number; (x: any): any; }
+>z[0] : { (x: number): number; (x: any): any; }
+>z : { (x: number): number; (x: any): any; }[]
+>0 : number
+
+var r5 = r4(''); // any not string
+>r5 : any
+>r4('') : any
+>r4 : { (x: number): number; (x: any): any; }
+>'' : string
+
+var r5b = r4(1);
+>r5b : number
+>r4(1) : number
+>r4 : { (x: number): number; (x: any): any; }
+>1 : number
+
+var a2: { <T>(x: T): number; (x: string): string;};
+>a2 : { <T>(x: T): number; (x: string): string; }
+>T : T
+>x : T
+>T : T
+>x : string
+
+var b2: { <T>(x: T): number; (x: string): string; };
+>b2 : { <T>(x: T): number; (x: string): string; }
+>T : T
+>x : T
+>T : T
+>x : string
+
+var c2: { (x: number): number; <T>(x: T): any; };
+>c2 : { (x: number): number; <T>(x: T): any; }
+>x : number
+>T : T
+>x : T
+>T : T
+
+var z2 = [a2, b2, c2];
+>z2 : { (x: number): number; <T>(x: T): any; }[]
+>[a2, b2, c2] : { (x: number): number; <T>(x: T): any; }[]
+>a2 : { <T>(x: T): number; (x: string): string; }
+>b2 : { <T>(x: T): number; (x: string): string; }
+>c2 : { (x: number): number; <T>(x: T): any; }
+
+var r6 = z2[0];
+>r6 : { (x: number): number; <T>(x: T): any; }
+>z2[0] : { (x: number): number; <T>(x: T): any; }
+>z2 : { (x: number): number; <T>(x: T): any; }[]
+>0 : number
+
+var r7 = r6(''); // any not string
+>r7 : any
+>r6('') : any
+>r6 : { (x: number): number; <T>(x: T): any; }
+>'' : string
+
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
index 933d46cc802..1191004a32b 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
@@ -46,8 +46,8 @@ var r = true ? 1 : 2;
 >2 : number
 
 var r3 = true ? 1 : {};
->r3 : number | {}
->true ? 1 : {} : number | {}
+>r3 : {}
+>true ? 1 : {} : {}
 >true : boolean
 >1 : number
 >{} : {}
@@ -67,8 +67,8 @@ var r5 = true ? b : a; // typeof b
 >a : { x: number; y?: number; }
 
 var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
->r6 : ((x: number) => void) | ((x: Object) => void)
->true ? (x: number) => { } : (x: Object) => { } : ((x: number) => void) | ((x: Object) => void)
+>r6 : (x: number) => void
+>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
 >true : boolean
 >(x: number) => { } : (x: number) => void
 >x : number
@@ -80,7 +80,7 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >r7 : (x: Object) => void
 >x : Object
 >Object : Object
->true ? (x: number) => { } : (x: Object) => { } : ((x: number) => void) | ((x: Object) => void)
+>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
 >true : boolean
 >(x: number) => { } : (x: number) => void
 >x : number
@@ -89,8 +89,8 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >Object : Object
 
 var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
->r8 : ((x: Object) => void) | ((x: number) => void)
->true ? (x: Object) => { } : (x: number) => { } : ((x: Object) => void) | ((x: number) => void)
+>r8 : (x: Object) => void
+>true ? (x: Object) => { } : (x: number) => { } : (x: Object) => void
 >true : boolean
 >(x: Object) => { } : (x: Object) => void
 >x : Object
@@ -107,8 +107,8 @@ var r10: Base = true ? derived : derived2; // no error since we use the contextu
 >derived2 : Derived2
 
 var r11 = true ? base : derived2;
->r11 : Base | Derived2
->true ? base : derived2 : Base | Derived2
+>r11 : Base
+>true ? base : derived2 : Base
 >true : boolean
 >base : Base
 >derived2 : Derived2
diff --git a/tests/baselines/reference/bestCommonTypeWithOptionalProperties.types b/tests/baselines/reference/bestCommonTypeWithOptionalProperties.types
index 4c47753a90d..df40291b0e5 100644
--- a/tests/baselines/reference/bestCommonTypeWithOptionalProperties.types
+++ b/tests/baselines/reference/bestCommonTypeWithOptionalProperties.types
@@ -27,43 +27,43 @@ var z: Z;
 
 // All these arrays should be X[]
 var b1 = [x, y, z];
->b1 : (X | Y | Z)[]
->[x, y, z] : (X | Y | Z)[]
+>b1 : X[]
+>[x, y, z] : X[]
 >x : X
 >y : Y
 >z : Z
 
 var b2 = [x, z, y];
->b2 : (X | Z | Y)[]
->[x, z, y] : (X | Z | Y)[]
+>b2 : X[]
+>[x, z, y] : X[]
 >x : X
 >z : Z
 >y : Y
 
 var b3 = [y, x, z];
->b3 : (Y | X | Z)[]
->[y, x, z] : (Y | X | Z)[]
+>b3 : X[]
+>[y, x, z] : X[]
 >y : Y
 >x : X
 >z : Z
 
 var b4 = [y, z, x];
->b4 : (Y | Z | X)[]
->[y, z, x] : (Y | Z | X)[]
+>b4 : X[]
+>[y, z, x] : X[]
 >y : Y
 >z : Z
 >x : X
 
 var b5 = [z, x, y];
->b5 : (Z | X | Y)[]
->[z, x, y] : (Z | X | Y)[]
+>b5 : X[]
+>[z, x, y] : X[]
 >z : Z
 >x : X
 >y : Y
 
 var b6 = [z, y, x];
->b6 : (Z | Y | X)[]
->[z, y, x] : (Z | Y | X)[]
+>b6 : X[]
+>[z, y, x] : X[]
 >z : Z
 >y : Y
 >x : X
diff --git a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
index d5530f98fe8..026c8f42272 100644
--- a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
+++ b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
@@ -31,21 +31,21 @@ var b: B;
 //Cond ? Expr1 : Expr2,  Expr1 is supertype
 //Be Not contextually typed
 true ? x : a;
->true ? x : a : X | A
+>true ? x : a : X
 >true : boolean
 >x : X
 >a : A
 
 var result1 = true ? x : a;
->result1 : X | A
->true ? x : a : X | A
+>result1 : X
+>true ? x : a : X
 >true : boolean
 >x : X
 >a : A
 
 //Expr1 and Expr2 are literals
 true ? {} : 1;
->true ? {} : 1 : {} | number
+>true ? {} : 1 : {}
 >true : boolean
 >{} : {}
 >1 : number
@@ -63,8 +63,8 @@ true ? { a: 1 } : { a: 2, b: 'string' };
 >'string' : string
 
 var result2 = true ? {} : 1;
->result2 : {} | number
->true ? {} : 1 : {} | number
+>result2 : {}
+>true ? {} : 1 : {}
 >true : boolean
 >{} : {}
 >1 : number
@@ -86,7 +86,7 @@ var result3 = true ? { a: 1 } : { a: 2, b: 'string' };
 var resultIsX1: X = true ? x : a;
 >resultIsX1 : X
 >X : X
->true ? x : a : X | A
+>true ? x : a : X
 >true : boolean
 >x : X
 >a : A
@@ -95,7 +95,7 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 >result4 : (t: A) => any
 >t : A
 >A : A
->true ? (m) => m.propertyX : (n) => n.propertyA : ((m: A) => any) | ((n: A) => number)
+>true ? (m) => m.propertyX : (n) => n.propertyA : (m: A) => any
 >true : boolean
 >(m) => m.propertyX : (m: A) => any
 >m : A
@@ -111,21 +111,21 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 //Cond ? Expr1 : Expr2,  Expr2 is supertype
 //Be Not contextually typed
 true ? a : x;
->true ? a : x : A | X
+>true ? a : x : X
 >true : boolean
 >a : A
 >x : X
 
 var result5 = true ? a : x;
->result5 : A | X
->true ? a : x : A | X
+>result5 : X
+>true ? a : x : X
 >true : boolean
 >a : A
 >x : X
 
 //Expr1 and Expr2 are literals
 true ? 1 : {};
->true ? 1 : {} : number | {}
+>true ? 1 : {} : {}
 >true : boolean
 >1 : number
 >{} : {}
@@ -143,8 +143,8 @@ true ? { a: 2, b: 'string' } : { a: 1 };
 >1 : number
 
 var result6 = true ? 1 : {};
->result6 : number | {}
->true ? 1 : {} : number | {}
+>result6 : {}
+>true ? 1 : {} : {}
 >true : boolean
 >1 : number
 >{} : {}
@@ -166,7 +166,7 @@ var result7 = true ? { a: 2, b: 'string' } : { a: 1 };
 var resultIsX2: X = true ? x : a;
 >resultIsX2 : X
 >X : X
->true ? x : a : X | A
+>true ? x : a : X
 >true : boolean
 >x : X
 >a : A
@@ -175,7 +175,7 @@ var result8: (t: A) => any = true ? (m) => m.propertyA : (n) => n.propertyX;
 >result8 : (t: A) => any
 >t : A
 >A : A
->true ? (m) => m.propertyA : (n) => n.propertyX : ((m: A) => number) | ((n: A) => any)
+>true ? (m) => m.propertyA : (n) => n.propertyX : (n: A) => any
 >true : boolean
 >(m) => m.propertyA : (m: A) => number
 >m : A
diff --git a/tests/baselines/reference/contextualTypingArrayOfLambdas.types b/tests/baselines/reference/contextualTypingArrayOfLambdas.types
index 0bb61604336..d3e5b9942e3 100644
--- a/tests/baselines/reference/contextualTypingArrayOfLambdas.types
+++ b/tests/baselines/reference/contextualTypingArrayOfLambdas.types
@@ -23,8 +23,8 @@ class C extends A {
 }
 
 var xs = [(x: A) => { }, (x: B) => { }, (x: C) => { }];
->xs : (((x: A) => void) | ((x: B) => void) | ((x: C) => void))[]
->[(x: A) => { }, (x: B) => { }, (x: C) => { }] : (((x: A) => void) | ((x: B) => void) | ((x: C) => void))[]
+>xs : ((x: A) => void)[]
+>[(x: A) => { }, (x: B) => { }, (x: C) => { }] : ((x: A) => void)[]
 >(x: A) => { } : (x: A) => void
 >x : A
 >A : A
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
index 098afe94b47..53ecb88363d 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | C2 | D<string>)[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     for( var arr = [new C(), new C2(), new D<string>()];;){}
              ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | C2 | D<string>)[]'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
     
     for(var arr2 = [new D<string>()];;){}
     for( var arr2 = new Array<D<number>>();;){}
diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types
index 4facd65bda7..1398e2974f0 100644
--- a/tests/baselines/reference/functionImplementations.types
+++ b/tests/baselines/reference/functionImplementations.types
@@ -342,7 +342,7 @@ var f7: (x: number) => string | number = x => { // should be (x: number) => numb
 var f8: (x: number) => any = x => { // should be (x: number) => Base
 >f8 : (x: number) => any
 >x : number
->x => { // should be (x: number) => Base    return new Base();    return new Derived2();} : (x: number) => Base | Derived2
+>x => { // should be (x: number) => Base    return new Base();    return new Derived2();} : (x: number) => Base
 >x : number
 
     return new Base();
@@ -356,7 +356,7 @@ var f8: (x: number) => any = x => { // should be (x: number) => Base
 var f9: (x: number) => any = x => { // should be (x: number) => Base
 >f9 : (x: number) => any
 >x : number
->x => { // should be (x: number) => Base    return new Base();    return new Derived();    return new Derived2();} : (x: number) => Base | Derived | Derived2
+>x => { // should be (x: number) => Base    return new Base();    return new Derived();    return new Derived2();} : (x: number) => Base
 >x : number
 
     return new Base();
diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types
index 06745d0d7aa..e8f434d31a8 100644
--- a/tests/baselines/reference/generatedContextualTyping.types
+++ b/tests/baselines/reference/generatedContextualTyping.types
@@ -2125,8 +2125,8 @@ var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 >d2 : Derived2
 
 var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
->x217 : (() => Base[]) | (() => (Derived1 | Derived2)[])
->(<() => Base[]>undefined) || function() { return [d1, d2] } : (() => Base[]) | (() => (Derived1 | Derived2)[])
+>x217 : () => Base[]
+>(<() => Base[]>undefined) || function() { return [d1, d2] } : () => Base[]
 >(<() => Base[]>undefined) : () => Base[]
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
@@ -2137,8 +2137,8 @@ var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
 >d2 : Derived2
 
 var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
->x218 : (() => Base[]) | (() => (Derived1 | Derived2)[])
->(<() => Base[]>undefined) || function named() { return [d1, d2] } : (() => Base[]) | (() => (Derived1 | Derived2)[])
+>x218 : () => Base[]
+>(<() => Base[]>undefined) || function named() { return [d1, d2] } : () => Base[]
 >(<() => Base[]>undefined) : () => Base[]
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
@@ -2150,8 +2150,8 @@ var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
 >d2 : Derived2
 
 var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
->x219 : (() => Base[]) | (() => (Derived1 | Derived2)[])
->(<{ (): Base[]; }>undefined) || function() { return [d1, d2] } : (() => Base[]) | (() => (Derived1 | Derived2)[])
+>x219 : () => Base[]
+>(<{ (): Base[]; }>undefined) || function() { return [d1, d2] } : () => Base[]
 >(<{ (): Base[]; }>undefined) : () => Base[]
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
@@ -2162,8 +2162,8 @@ var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
 >d2 : Derived2
 
 var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
->x220 : (() => Base[]) | (() => (Derived1 | Derived2)[])
->(<{ (): Base[]; }>undefined) || function named() { return [d1, d2] } : (() => Base[]) | (() => (Derived1 | Derived2)[])
+>x220 : () => Base[]
+>(<{ (): Base[]; }>undefined) || function named() { return [d1, d2] } : () => Base[]
 >(<{ (): Base[]; }>undefined) : () => Base[]
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
@@ -2175,8 +2175,8 @@ var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
 >d2 : Derived2
 
 var x221 = (<Base[]>undefined) || [d1, d2];
->x221 : Base[] | (Derived1 | Derived2)[]
->(<Base[]>undefined) || [d1, d2] : Base[] | (Derived1 | Derived2)[]
+>x221 : Base[]
+>(<Base[]>undefined) || [d1, d2] : Base[]
 >(<Base[]>undefined) : Base[]
 ><Base[]>undefined : Base[]
 >Base : Base
@@ -2186,8 +2186,8 @@ var x221 = (<Base[]>undefined) || [d1, d2];
 >d2 : Derived2
 
 var x222 = (<Array<Base>>undefined) || [d1, d2];
->x222 : Base[] | (Derived1 | Derived2)[]
->(<Array<Base>>undefined) || [d1, d2] : Base[] | (Derived1 | Derived2)[]
+>x222 : Base[]
+>(<Array<Base>>undefined) || [d1, d2] : Base[]
 >(<Array<Base>>undefined) : Base[]
 ><Array<Base>>undefined : Base[]
 >Array : T[]
@@ -2198,8 +2198,8 @@ var x222 = (<Array<Base>>undefined) || [d1, d2];
 >d2 : Derived2
 
 var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
->x223 : { [n: number]: Base; } | (Derived1 | Derived2)[]
->(<{ [n: number]: Base; }>undefined) || [d1, d2] : { [n: number]: Base; } | (Derived1 | Derived2)[]
+>x223 : { [n: number]: Base; }
+>(<{ [n: number]: Base; }>undefined) || [d1, d2] : { [n: number]: Base; }
 >(<{ [n: number]: Base; }>undefined) : { [n: number]: Base; }
 ><{ [n: number]: Base; }>undefined : { [n: number]: Base; }
 >n : number
@@ -2210,8 +2210,8 @@ var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
 >d2 : Derived2
 
 var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
->x224 : { n: Base[]; } | { n: (Derived1 | Derived2)[]; }
->(<{n: Base[]; } >undefined) || { n: [d1, d2] } : { n: Base[]; } | { n: (Derived1 | Derived2)[]; }
+>x224 : { n: Base[]; }
+>(<{n: Base[]; } >undefined) || { n: [d1, d2] } : { n: Base[]; }
 >(<{n: Base[]; } >undefined) : { n: Base[]; }
 ><{n: Base[]; } >undefined : { n: Base[]; }
 >n : Base[]
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.types b/tests/baselines/reference/heterogeneousArrayLiterals.types
index 952200d74f8..c760e5a566f 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.types
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.types
@@ -21,14 +21,14 @@ var c = [1, '', null]; // {}[]
 >null : null
 
 var d = [{}, 1]; // {}[]
->d : ({} | number)[]
->[{}, 1] : ({} | number)[]
+>d : {}[]
+>[{}, 1] : {}[]
 >{} : {}
 >1 : number
 
 var e = [{}, Object]; // {}[]
->e : ({} | ObjectConstructor)[]
->[{}, Object] : ({} | ObjectConstructor)[]
+>e : {}[]
+>[{}, Object] : {}[]
 >{} : {}
 >Object : ObjectConstructor
 
@@ -88,16 +88,16 @@ var k = [() => 1, () => 1]; // { (): number }[]
 >1 : number
 
 var l = [() => 1, () => null]; // { (): any }[]
->l : ((() => number) | (() => any))[]
->[() => 1, () => null] : ((() => number) | (() => any))[]
+>l : (() => any)[]
+>[() => 1, () => null] : (() => any)[]
 >() => 1 : () => number
 >1 : number
 >() => null : () => any
 >null : null
 
 var m = [() => 1, () => '', () => null]; // { (): any }[]
->m : ((() => number) | (() => string) | (() => any))[]
->[() => 1, () => '', () => null] : ((() => number) | (() => string) | (() => any))[]
+>m : (() => any)[]
+>[() => 1, () => '', () => null] : (() => any)[]
 >() => 1 : () => number
 >1 : number
 >() => '' : () => string
@@ -169,8 +169,8 @@ module Derived {
 >derived : Derived
 
     var j = [() => base, () => derived]; // { {}: Base }
->j : ((() => Base) | (() => Derived))[]
->[() => base, () => derived] : ((() => Base) | (() => Derived))[]
+>j : (() => Base)[]
+>[() => base, () => derived] : (() => Base)[]
 >() => base : () => Base
 >base : Base
 >() => derived : () => Derived
@@ -185,16 +185,16 @@ module Derived {
 >1 : number
 
     var l = [() => base, () => null]; // { (): any }[]
->l : ((() => Base) | (() => any))[]
->[() => base, () => null] : ((() => Base) | (() => any))[]
+>l : (() => any)[]
+>[() => base, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
 >() => null : () => any
 >null : null
 
     var m = [() => base, () => derived, () => null]; // { (): any }[]
->m : ((() => Base) | (() => Derived) | (() => any))[]
->[() => base, () => derived, () => null] : ((() => Base) | (() => Derived) | (() => any))[]
+>m : (() => any)[]
+>[() => base, () => derived, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
 >() => derived : () => Derived
@@ -203,8 +203,8 @@ module Derived {
 >null : null
 
     var n = [[() => base], [() => derived]]; // { (): Base }[]
->n : ((() => Base)[] | (() => Derived)[])[]
->[[() => base], [() => derived]] : ((() => Base)[] | (() => Derived)[])[]
+>n : (() => Base)[][]
+>[[() => base], [() => derived]] : (() => Base)[][]
 >[() => base] : (() => Base)[]
 >() => base : () => Base
 >base : Base
@@ -219,8 +219,8 @@ module Derived {
 >derived2 : Derived2
 
     var p = [derived, derived2, base]; // Base[]
->p : (Derived | Derived2 | Base)[]
->[derived, derived2, base] : (Derived | Derived2 | Base)[]
+>p : Base[]
+>[derived, derived2, base] : Base[]
 >derived : Derived
 >derived2 : Derived2
 >base : Base
@@ -310,8 +310,8 @@ function foo<T, U>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U) | (() => any))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U) | (() => any))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -364,8 +364,8 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U) | (() => any))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U) | (() => any))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -374,8 +374,8 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >null : null
 
     var g = [t, base]; // Base[]
->g : (T | Base)[]
->[t, base] : (T | Base)[]
+>g : Base[]
+>[t, base] : Base[]
 >t : T
 >base : Base
 
@@ -386,14 +386,14 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >derived : Derived
 
     var i = [u, base]; // Base[]
->i : (U | Base)[]
->[u, base] : (U | Base)[]
+>i : Base[]
+>[u, base] : Base[]
 >u : U
 >base : Base
 
     var j = [u, derived]; // Derived[]
->j : (U | Derived)[]
->[u, derived] : (U | Derived)[]
+>j : Derived[]
+>[u, derived] : Derived[]
 >u : U
 >derived : Derived
 }
@@ -442,8 +442,8 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U) | (() => any))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U) | (() => any))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -452,26 +452,26 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 >null : null
 
     var g = [t, base]; // Base[]
->g : (T | Base)[]
->[t, base] : (T | Base)[]
+>g : Base[]
+>[t, base] : Base[]
 >t : T
 >base : Base
 
     var h = [t, derived]; // Derived[]
->h : (T | Derived)[]
->[t, derived] : (T | Derived)[]
+>h : Derived[]
+>[t, derived] : Derived[]
 >t : T
 >derived : Derived
 
     var i = [u, base]; // Base[]
->i : (U | Base)[]
->[u, base] : (U | Base)[]
+>i : Base[]
+>[u, base] : Base[]
 >u : U
 >base : Base
 
     var j = [u, derived]; // Derived[]
->j : (U | Derived)[]
->[u, derived] : (U | Derived)[]
+>j : Derived[]
+>[u, derived] : Derived[]
 >u : U
 >derived : Derived
 }
@@ -520,8 +520,8 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U) | (() => any))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U) | (() => any))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -530,8 +530,8 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >null : null
 
     var g = [t, base]; // Base[]
->g : (T | Base)[]
->[t, base] : (T | Base)[]
+>g : Base[]
+>[t, base] : Base[]
 >t : T
 >base : Base
 
@@ -542,8 +542,8 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >derived : Derived
 
     var i = [u, base]; // Base[]
->i : (U | Base)[]
->[u, base] : (U | Base)[]
+>i : Base[]
+>[u, base] : Base[]
 >u : U
 >base : Base
 
diff --git a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
index 0c4b95214b0..3ec718f3b25 100644
--- a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
+++ b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(40,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(43,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(46,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | C2 | D<string>)[]'.
+tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(50,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(53,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     var arr = [new C(), new C2(), new D<string>()];
         ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | C2 | D<string>)[]'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
     
     var arr2 = [new D<string>()];
     var arr2 = new Array<D<number>>();
diff --git a/tests/baselines/reference/logicalOrOperatorWithEveryType.types b/tests/baselines/reference/logicalOrOperatorWithEveryType.types
index 04bc188e308..4540e35aaf4 100644
--- a/tests/baselines/reference/logicalOrOperatorWithEveryType.types
+++ b/tests/baselines/reference/logicalOrOperatorWithEveryType.types
@@ -187,8 +187,8 @@ var rc5 = a5 || a3;         // void      || number is void | number
 >a3 : number
 
 var rc6 = a6 || a3;         // enum      || number is number
->rc6 : E | number
->a6 || a3 : E | number
+>rc6 : number
+>a6 || a3 : number
 >a6 : E
 >a3 : number
 
@@ -349,8 +349,8 @@ var rg2 = a2 || a6;         // boolean   || enum is boolean | enum
 >a6 : E
 
 var rg3 = a3 || a6;         // number    || enum is number
->rg3 : number | E
->a3 || a6 : number | E
+>rg3 : number
+>a3 || a6 : number
 >a3 : number
 >a6 : E
 
diff --git a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
index df8f6cac6db..f887ad7ae14 100644
--- a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
+++ b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
@@ -107,8 +107,8 @@ function fn3<T extends { a: string; b: string }, U extends { a: string; b: numbe
 >u : U
 
     var r3 = t || { a: '' };
->r3 : T | { a: string; }
->t || { a: '' } : T | { a: string; }
+>r3 : { a: string; }
+>t || { a: '' } : { a: string; }
 >t : T
 >{ a: '' } : { a: string; }
 >a : string
diff --git a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
index 71e164d5d62..ff18160e9a5 100644
--- a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
@@ -1,9 +1,9 @@
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(16,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(25,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(34,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: A | B | number; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: A | number; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
   Index signatures are incompatible.
-    Type 'A | B | number' is not assignable to type 'A'.
+    Type 'A | number' is not assignable to type 'A'.
       Type 'number' is not assignable to type 'A'.
 
 
@@ -54,9 +54,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
     // error
     var b: { [x: number]: A } = {
         ~
-!!! error TS2322: Type '{ [x: number]: A | B | number; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
+!!! error TS2322: Type '{ [x: number]: A | number; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
 !!! error TS2322:   Index signatures are incompatible.
-!!! error TS2322:     Type 'A | B | number' is not assignable to type 'A'.
+!!! error TS2322:     Type 'A | number' is not assignable to type 'A'.
 !!! error TS2322:       Type 'number' is not assignable to type 'A'.
         1.0: new A(), 
         2.0: new B(), 
diff --git a/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt b/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
index edb6d031b1f..c35e49f02a3 100644
--- a/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
+++ b/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/objectLiteralIndexerErrors.ts(13,5): error TS2322: Type '{ [x: string]: B | A; [x: number]: A; 0: A; x: B; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
+tests/cases/compiler/objectLiteralIndexerErrors.ts(13,5): error TS2322: Type '{ [x: string]: A; [x: number]: A; 0: A; x: B; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
   Index signatures are incompatible.
     Type 'A' is not assignable to type 'B'.
 
@@ -18,7 +18,7 @@ tests/cases/compiler/objectLiteralIndexerErrors.ts(13,5): error TS2322: Type '{
     
     var o1: { [s: string]: A;[n: number]: B; } = { x: b, 0: a }; // both indexers are A
         ~~
-!!! error TS2322: Type '{ [x: string]: B | A; [x: number]: A; 0: A; x: B; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
+!!! error TS2322: Type '{ [x: string]: A; [x: number]: A; 0: A; x: B; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
 !!! error TS2322:   Index signatures are incompatible.
 !!! error TS2322:     Type 'A' is not assignable to type 'B'.
     o1 = { x: c, 0: a }; // string indexer is any, number indexer is A
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLiteralIndexers.types b/tests/baselines/reference/objectLiteralIndexers.types
index 55cec857c70..d5add00ebaf 100644
--- a/tests/baselines/reference/objectLiteralIndexers.types
+++ b/tests/baselines/reference/objectLiteralIndexers.types
@@ -31,7 +31,7 @@ var o1: { [s: string]: A;[n: number]: B; } = { x: a, 0: b }; // string indexer i
 >A : A
 >n : number
 >B : B
->{ x: a, 0: b } : { [x: string]: A | B; [x: number]: B; 0: B; x: A; }
+>{ x: a, 0: b } : { [x: string]: A; [x: number]: B; 0: B; x: A; }
 >x : A
 >a : A
 >b : B
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.types b/tests/baselines/reference/parenthesizedContexualTyping1.types
index 1423901a28f..61ec1a24ec5 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.types
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.types
@@ -149,8 +149,8 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
 >i : number
 >fun((Math.random() < 0.5 ? x => x : x => undefined), 10) : number
 >fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
->(Math.random() < 0.5 ? x => x : x => undefined) : ((x: number) => number) | ((x: number) => any)
->Math.random() < 0.5 ? x => x : x => undefined : ((x: number) => number) | ((x: number) => any)
+>(Math.random() < 0.5 ? x => x : x => undefined) : (x: number) => any
+>Math.random() < 0.5 ? x => x : x => undefined : (x: number) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -169,8 +169,8 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
 >j : number
 >fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10) : number
 >fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
->(Math.random() < 0.5 ? (x => x) : (x => undefined)) : ((x: number) => number) | ((x: number) => any)
->Math.random() < 0.5 ? (x => x) : (x => undefined) : ((x: number) => number) | ((x: number) => any)
+>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any
+>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -191,8 +191,8 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
 >k : number
 >fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10) : number
 >fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
->(Math.random() < 0.5 ? (x => x) : (x => undefined)) : ((x: number) => number) | ((x: number) => any)
->Math.random() < 0.5 ? (x => x) : (x => undefined) : ((x: number) => number) | ((x: number) => any)
+>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any
+>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -216,9 +216,9 @@ var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)
 >l : number
 >fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10) : number
 >fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
->((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))) : ((x: number) => number) | ((x: number) => any)
->(Math.random() < 0.5 ? ((x => x)) : ((x => undefined))) : ((x: number) => number) | ((x: number) => any)
->Math.random() < 0.5 ? ((x => x)) : ((x => undefined)) : ((x: number) => number) | ((x: number) => any)
+>((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))) : (x: number) => any
+>(Math.random() < 0.5 ? ((x => x)) : ((x => undefined))) : (x: number) => any
+>Math.random() < 0.5 ? ((x => x)) : ((x => undefined)) : (x: number) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.types b/tests/baselines/reference/parenthesizedContexualTyping2.types
index 344933ea1fc..a055f2f1bbd 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.types
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.types
@@ -186,8 +186,8 @@ var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x
 >i : number
 >fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10) : number
 >fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
->(Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
->Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
+>(Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined : (x: <T>(p: T) => T) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -209,8 +209,8 @@ var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >j : number
 >fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10) : number
 >fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
->(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
->Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
+>(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : (x: <T>(p: T) => T) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -234,8 +234,8 @@ var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 >k : number
 >fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10) : number
 >fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
->(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
->Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
+>(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : (x: <T>(p: T) => T) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
@@ -265,9 +265,9 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; }))
 >l : number
 >fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10) : number
 >fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
->((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
->(Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined))) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
->Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)) : ((x: <T>(p: T) => T) => <T>(p: T) => T) | ((x: <T>(p: T) => T) => any)
+>((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))) : (x: <T>(p: T) => T) => any
+>(Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined))) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)) : (x: <T>(p: T) => T) => any
 >Math.random() < 0.5 : boolean
 >Math.random() : number
 >Math.random : () => number
diff --git a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
index e6cba35be25..1f4ee3debed 100644
--- a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
@@ -22,9 +22,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(71,5): error TS2411: Property 'foo' of type '() => string' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(73,5): error TS2411: Property '"4.0"' of type 'number' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(74,5): error TS2411: Property 'f' of type 'MyString' is not assignable to string index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: string | number | (() => void) | MyString | (() => string); 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: string | number | (() => void) | MyString; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
   Index signatures are incompatible.
-    Type 'string | number | (() => void) | MyString | (() => string)' is not assignable to type 'string'.
+    Type 'string | number | (() => void) | MyString' is not assignable to type 'string'.
       Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(90,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(93,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -160,9 +160,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
     // error
     var b: { [x: string]: string; } = {
         ~
-!!! error TS2322: Type '{ [x: string]: string | number | (() => void) | MyString | (() => string); 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
+!!! error TS2322: Type '{ [x: string]: string | number | (() => void) | MyString; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
 !!! error TS2322:   Index signatures are incompatible.
-!!! error TS2322:     Type 'string | number | (() => void) | MyString | (() => string)' is not assignable to type 'string'.
+!!! error TS2322:     Type 'string | number | (() => void) | MyString' is not assignable to type 'string'.
 !!! error TS2322:       Type 'number' is not assignable to type 'string'.
         a: '',
         b: 1, 
diff --git a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.errors.txt b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.errors.txt
index 13d5adcf1f5..faef7905453 100644
--- a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.errors.txt
+++ b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.errors.txt
@@ -4,11 +4,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts(24,5): error TS2411: Property 'd' of type 'string' is not assignable to string index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts(31,5): error TS2411: Property 'c' of type 'number' is not assignable to string index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts(32,5): error TS2411: Property 'd' of type 'string' is not assignable to string index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts(36,5): error TS2322: Type '{ [x: string]: typeof A | typeof B; a: typeof A; b: typeof B; }' is not assignable to type '{ [x: string]: A; }'.
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts(36,5): error TS2322: Type '{ [x: string]: typeof A; a: typeof A; b: typeof B; }' is not assignable to type '{ [x: string]: A; }'.
   Index signatures are incompatible.
-    Type 'typeof A | typeof B' is not assignable to type 'A'.
-      Type 'typeof A' is not assignable to type 'A'.
-        Property 'foo' is missing in type 'typeof A'.
+    Type 'typeof A' is not assignable to type 'A'.
+      Property 'foo' is missing in type 'typeof A'.
 
 
 ==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations2.ts (7 errors) ====
@@ -61,11 +60,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
     // error
     var b: { [x: string]: A } = {
         ~
-!!! error TS2322: Type '{ [x: string]: typeof A | typeof B; a: typeof A; b: typeof B; }' is not assignable to type '{ [x: string]: A; }'.
+!!! error TS2322: Type '{ [x: string]: typeof A; a: typeof A; b: typeof B; }' is not assignable to type '{ [x: string]: A; }'.
 !!! error TS2322:   Index signatures are incompatible.
-!!! error TS2322:     Type 'typeof A | typeof B' is not assignable to type 'A'.
-!!! error TS2322:       Type 'typeof A' is not assignable to type 'A'.
-!!! error TS2322:         Property 'foo' is missing in type 'typeof A'.
+!!! error TS2322:     Type 'typeof A' is not assignable to type 'A'.
+!!! error TS2322:       Property 'foo' is missing in type 'typeof A'.
         a: A,
         b: B
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.types b/tests/baselines/reference/subtypingWithCallSignatures2.types
index e43382766ac..b72993e7bea 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.types
@@ -331,14 +331,14 @@ var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
 >r1arg1 : <T>(x: T) => T[]
 
 var r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions
->r1a : (((x: number) => number[]) | (<T>(x: T) => T[]))[]
->[r1arg2, r1arg1] : (((x: number) => number[]) | (<T>(x: T) => T[]))[]
+>r1a : (<T>(x: T) => T[])[]
+>[r1arg2, r1arg1] : (<T>(x: T) => T[])[]
 >r1arg2 : (x: number) => number[]
 >r1arg1 : <T>(x: T) => T[]
 
 var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
->r1b : ((<T>(x: T) => T[]) | ((x: number) => number[]))[]
->[r1arg1, r1arg2] : ((<T>(x: T) => T[]) | ((x: number) => number[]))[]
+>r1b : (<T>(x: T) => T[])[]
+>[r1arg1, r1arg2] : (<T>(x: T) => T[])[]
 >r1arg1 : <T>(x: T) => T[]
 >r1arg2 : (x: number) => number[]
 
@@ -365,14 +365,14 @@ var r2 = foo2(r2arg1);
 >r2arg1 : <T>(x: T) => string[]
 
 var r2a = [r2arg1, r2arg2];
->r2a : ((<T>(x: T) => string[]) | ((x: number) => string[]))[]
->[r2arg1, r2arg2] : ((<T>(x: T) => string[]) | ((x: number) => string[]))[]
+>r2a : (<T>(x: T) => string[])[]
+>[r2arg1, r2arg2] : (<T>(x: T) => string[])[]
 >r2arg1 : <T>(x: T) => string[]
 >r2arg2 : (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : (((x: number) => string[]) | (<T>(x: T) => string[]))[]
->[r2arg2, r2arg1] : (((x: number) => string[]) | (<T>(x: T) => string[]))[]
+>r2b : ((x: number) => string[])[]
+>[r2arg2, r2arg1] : ((x: number) => string[])[]
 >r2arg2 : (x: number) => string[]
 >r2arg1 : <T>(x: T) => string[]
 
@@ -396,14 +396,14 @@ var r3 = foo3(r3arg1);
 >r3arg1 : <T>(x: T) => T
 
 var r3a = [r3arg1, r3arg2];
->r3a : ((<T>(x: T) => T) | ((x: number) => void))[]
->[r3arg1, r3arg2] : ((<T>(x: T) => T) | ((x: number) => void))[]
+>r3a : (<T>(x: T) => T)[]
+>[r3arg1, r3arg2] : (<T>(x: T) => T)[]
 >r3arg1 : <T>(x: T) => T
 >r3arg2 : (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : (((x: number) => void) | (<T>(x: T) => T))[]
->[r3arg2, r3arg1] : (((x: number) => void) | (<T>(x: T) => T))[]
+>r3b : ((x: number) => void)[]
+>[r3arg2, r3arg1] : ((x: number) => void)[]
 >r3arg2 : (x: number) => void
 >r3arg1 : <T>(x: T) => T
 
@@ -432,14 +432,14 @@ var r4 = foo4(r4arg1); // any
 >r4arg1 : <T, U>(x: T, y: U) => T
 
 var r4a = [r4arg1, r4arg2];
->r4a : ((<T, U>(x: T, y: U) => T) | ((x: string, y: number) => string))[]
->[r4arg1, r4arg2] : ((<T, U>(x: T, y: U) => T) | ((x: string, y: number) => string))[]
+>r4a : (<T, U>(x: T, y: U) => T)[]
+>[r4arg1, r4arg2] : (<T, U>(x: T, y: U) => T)[]
 >r4arg1 : <T, U>(x: T, y: U) => T
 >r4arg2 : (x: string, y: number) => string
 
 var r4b = [r4arg2, r4arg1];
->r4b : (((x: string, y: number) => string) | (<T, U>(x: T, y: U) => T))[]
->[r4arg2, r4arg1] : (((x: string, y: number) => string) | (<T, U>(x: T, y: U) => T))[]
+>r4b : (<T, U>(x: T, y: U) => T)[]
+>[r4arg2, r4arg1] : (<T, U>(x: T, y: U) => T)[]
 >r4arg2 : (x: string, y: number) => string
 >r4arg1 : <T, U>(x: T, y: U) => T
 
@@ -470,14 +470,14 @@ var r5 = foo5(r5arg1); // any
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 
 var r5a = [r5arg1, r5arg2];
->r5a : ((<T, U>(x: (arg: T) => U) => T) | ((x: (arg: string) => number) => string))[]
->[r5arg1, r5arg2] : ((<T, U>(x: (arg: T) => U) => T) | ((x: (arg: string) => number) => string))[]
+>r5a : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg1, r5arg2] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 >r5arg2 : (x: (arg: string) => number) => string
 
 var r5b = [r5arg2, r5arg1];
->r5b : (((x: (arg: string) => number) => string) | (<T, U>(x: (arg: T) => U) => T))[]
->[r5arg2, r5arg1] : (((x: (arg: string) => number) => string) | (<T, U>(x: (arg: T) => U) => T))[]
+>r5b : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg2, r5arg1] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg2 : (x: (arg: string) => number) => string
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 
@@ -514,14 +514,14 @@ var r6 = foo6(r6arg1); // any
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
 var r6a = [r6arg1, r6arg2];
->r6a : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => T) | ((x: (arg: Base) => Derived) => Base))[]
->[r6arg1, r6arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => T) | ((x: (arg: Base) => Derived) => Base))[]
+>r6a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg1, r6arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 >r6arg2 : (x: (arg: Base) => Derived) => Base
 
 var r6b = [r6arg2, r6arg1];
->r6b : (((x: (arg: Base) => Derived) => Base) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => T))[]
->[r6arg2, r6arg1] : (((x: (arg: Base) => Derived) => Base) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => T))[]
+>r6b : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg2, r6arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg2 : (x: (arg: Base) => Derived) => Base
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
@@ -564,14 +564,14 @@ var r7 = foo7(r7arg1); // any
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 
 var r7a = [r7arg1, r7arg2];
->r7a : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U) | ((x: (arg: Base) => Derived) => (r: Base) => Derived))[]
->[r7arg1, r7arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U) | ((x: (arg: Base) => Derived) => (r: Base) => Derived))[]
+>r7a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
+>[r7arg1, r7arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 >r7arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived
 
 var r7b = [r7arg2, r7arg1];
->r7b : (((x: (arg: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U))[]
->[r7arg2, r7arg1] : (((x: (arg: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U))[]
+>r7b : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
+>[r7arg2, r7arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
 >r7arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 
@@ -622,14 +622,14 @@ var r8 = foo8(r8arg1); // any
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 
 var r8a = [r8arg1, r8arg2];
->r8a : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
->[r8arg1, r8arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
+>r8a : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
+>[r8arg1, r8arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 >r8arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var r8b = [r8arg2, r8arg1];
->r8b : (((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U))[]
->[r8arg2, r8arg1] : (((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U))[]
+>r8b : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
+>[r8arg2, r8arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
 >r8arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 
@@ -681,14 +681,14 @@ var r9 = foo9(r9arg1); // any
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 
 var r9a = [r9arg1, r9arg2];
->r9a : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
->[r9arg1, r9arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
+>r9a : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
+>[r9arg1, r9arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 >r9arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var r9b = [r9arg2, r9arg1];
->r9b : (((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U))[]
->[r9arg2, r9arg1] : (((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived) | (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U))[]
+>r9b : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
+>[r9arg2, r9arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
 >r9arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 
@@ -719,14 +719,14 @@ var r10 = foo10(r10arg1); // any
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 
 var r10a = [r10arg1, r10arg2];
->r10a : ((<T extends Derived>(...x: T[]) => T) | ((...x: Derived[]) => Derived))[]
->[r10arg1, r10arg2] : ((<T extends Derived>(...x: T[]) => T) | ((...x: Derived[]) => Derived))[]
+>r10a : (<T extends Derived>(...x: T[]) => T)[]
+>[r10arg1, r10arg2] : (<T extends Derived>(...x: T[]) => T)[]
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 >r10arg2 : (...x: Derived[]) => Derived
 
 var r10b = [r10arg2, r10arg1];
->r10b : (((...x: Derived[]) => Derived) | (<T extends Derived>(...x: T[]) => T))[]
->[r10arg2, r10arg1] : (((...x: Derived[]) => Derived) | (<T extends Derived>(...x: T[]) => T))[]
+>r10b : (<T extends Derived>(...x: T[]) => T)[]
+>[r10arg2, r10arg1] : (<T extends Derived>(...x: T[]) => T)[]
 >r10arg2 : (...x: Derived[]) => Derived
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 
@@ -760,14 +760,14 @@ var r11 = foo11(r11arg1); // any
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 
 var r11a = [r11arg1, r11arg2];
->r11a : ((<T extends Base>(x: T, y: T) => T) | ((x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
->[r11arg1, r11arg2] : ((<T extends Base>(x: T, y: T) => T) | ((x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
+>r11a : (<T extends Base>(x: T, y: T) => T)[]
+>[r11arg1, r11arg2] : (<T extends Base>(x: T, y: T) => T)[]
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 >r11arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var r11b = [r11arg2, r11arg1];
->r11b : (((x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (<T extends Base>(x: T, y: T) => T))[]
->[r11arg2, r11arg1] : (((x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (<T extends Base>(x: T, y: T) => T))[]
+>r11b : (<T extends Base>(x: T, y: T) => T)[]
+>[r11arg2, r11arg1] : (<T extends Base>(x: T, y: T) => T)[]
 >r11arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 
@@ -808,14 +808,14 @@ var r12 = foo12(r12arg1); // any
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 
 var r12a = [r12arg1, r12arg2];
->r12a : ((<T extends Base[]>(x: Base[], y: T) => Derived[]) | ((x: Base[], y: Derived2[]) => Derived[]))[]
->[r12arg1, r12arg2] : ((<T extends Base[]>(x: Base[], y: T) => Derived[]) | ((x: Base[], y: Derived2[]) => Derived[]))[]
+>r12a : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg1, r12arg2] : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : (((x: Base[], y: Derived2[]) => Derived[]) | (<T extends Base[]>(x: Base[], y: T) => Derived[]))[]
->[r12arg2, r12arg1] : (((x: Base[], y: Derived2[]) => Derived[]) | (<T extends Base[]>(x: Base[], y: T) => Derived[]))[]
+>r12b : ((x: Base[], y: Derived2[]) => Derived[])[]
+>[r12arg2, r12arg1] : ((x: Base[], y: Derived2[]) => Derived[])[]
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 
@@ -853,14 +853,14 @@ var r13 = foo13(r13arg1); // any
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 
 var r13a = [r13arg1, r13arg2];
->r13a : ((<T extends Derived[]>(x: Base[], y: T) => T) | ((x: Base[], y: Derived[]) => Derived[]))[]
->[r13arg1, r13arg2] : ((<T extends Derived[]>(x: Base[], y: T) => T) | ((x: Base[], y: Derived[]) => Derived[]))[]
+>r13a : (<T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg1, r13arg2] : (<T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 >r13arg2 : (x: Base[], y: Derived[]) => Derived[]
 
 var r13b = [r13arg2, r13arg1];
->r13b : (((x: Base[], y: Derived[]) => Derived[]) | (<T extends Derived[]>(x: Base[], y: T) => T))[]
->[r13arg2, r13arg1] : (((x: Base[], y: Derived[]) => Derived[]) | (<T extends Derived[]>(x: Base[], y: T) => T))[]
+>r13b : (<T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg2, r13arg1] : (<T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg2 : (x: Base[], y: Derived[]) => Derived[]
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 
@@ -894,14 +894,14 @@ var r14 = foo14(r14arg1); // any
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 
 var r14a = [r14arg1, r14arg2];
->r14a : ((<T>(x: { a: T; b: T; }) => T) | ((x: { a: string; b: number; }) => Object))[]
->[r14arg1, r14arg2] : ((<T>(x: { a: T; b: T; }) => T) | ((x: { a: string; b: number; }) => Object))[]
+>r14a : (<T>(x: { a: T; b: T; }) => T)[]
+>[r14arg1, r14arg2] : (<T>(x: { a: T; b: T; }) => T)[]
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 >r14arg2 : (x: { a: string; b: number; }) => Object
 
 var r14b = [r14arg2, r14arg1];
->r14b : (((x: { a: string; b: number; }) => Object) | (<T>(x: { a: T; b: T; }) => T))[]
->[r14arg2, r14arg1] : (((x: { a: string; b: number; }) => Object) | (<T>(x: { a: T; b: T; }) => T))[]
+>r14b : (<T>(x: { a: T; b: T; }) => T)[]
+>[r14arg2, r14arg1] : (<T>(x: { a: T; b: T; }) => T)[]
 >r14arg2 : (x: { a: string; b: number; }) => Object
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.types b/tests/baselines/reference/subtypingWithCallSignatures3.types
index 0d3a84ac99c..2d4c6e9fda5 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.types
@@ -219,8 +219,8 @@ module Errors {
 >null : null
 
     var r1a = [(x: number) => [''], <T, U>(x: T) => <U[]>null];
->r1a : (((x: number) => string[]) | (<T, U>(x: T) => U[]))[]
->[(x: number) => [''], <T, U>(x: T) => <U[]>null] : (((x: number) => string[]) | (<T, U>(x: T) => U[]))[]
+>r1a : (<T, U>(x: T) => U[])[]
+>[(x: number) => [''], <T, U>(x: T) => <U[]>null] : (<T, U>(x: T) => U[])[]
 >(x: number) => [''] : (x: number) => string[]
 >x : number
 >[''] : string[]
@@ -235,8 +235,8 @@ module Errors {
 >null : null
 
     var r1b = [<T, U>(x: T) => <U[]>null, (x: number) => ['']];
->r1b : ((<T, U>(x: T) => U[]) | ((x: number) => string[]))[]
->[<T, U>(x: T) => <U[]>null, (x: number) => ['']] : ((<T, U>(x: T) => U[]) | ((x: number) => string[]))[]
+>r1b : (<T, U>(x: T) => U[])[]
+>[<T, U>(x: T) => <U[]>null, (x: number) => ['']] : (<T, U>(x: T) => U[])[]
 ><T, U>(x: T) => <U[]>null : <T, U>(x: T) => U[]
 >T : T
 >U : U
@@ -291,14 +291,14 @@ module Errors {
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 
     var r2a = [r2arg2, r2arg];
->r2a : (((x: (arg: Base) => Derived) => (r: Base) => Derived2) | (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V))[]
->[r2arg2, r2arg] : (((x: (arg: Base) => Derived) => (r: Base) => Derived2) | (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V))[]
+>r2a : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
+>[r2arg2, r2arg] : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
 >r2arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 
     var r2b = [r2arg, r2arg2];
->r2b : ((<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V) | ((x: (arg: Base) => Derived) => (r: Base) => Derived2))[]
->[r2arg, r2arg2] : ((<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V) | ((x: (arg: Base) => Derived) => (r: Base) => Derived2))[]
+>r2b : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
+>[r2arg, r2arg2] : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 >r2arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
 
@@ -387,14 +387,14 @@ module Errors {
 >r4arg : <T extends Derived>(...x: T[]) => T
 
     var r4a = [r4arg2, r4arg];
->r4a : (((...x: Base[]) => Base) | (<T extends Derived>(...x: T[]) => T))[]
->[r4arg2, r4arg] : (((...x: Base[]) => Base) | (<T extends Derived>(...x: T[]) => T))[]
+>r4a : (<T extends Derived>(...x: T[]) => T)[]
+>[r4arg2, r4arg] : (<T extends Derived>(...x: T[]) => T)[]
 >r4arg2 : (...x: Base[]) => Base
 >r4arg : <T extends Derived>(...x: T[]) => T
 
     var r4b = [r4arg, r4arg2];
->r4b : ((<T extends Derived>(...x: T[]) => T) | ((...x: Base[]) => Base))[]
->[r4arg, r4arg2] : ((<T extends Derived>(...x: T[]) => T) | ((...x: Base[]) => Base))[]
+>r4b : (<T extends Derived>(...x: T[]) => T)[]
+>[r4arg, r4arg2] : (<T extends Derived>(...x: T[]) => T)[]
 >r4arg : <T extends Derived>(...x: T[]) => T
 >r4arg2 : (...x: Base[]) => Base
 
@@ -430,14 +430,14 @@ module Errors {
 >r5arg : <T extends Derived>(x: T, y: T) => T
 
     var r5a = [r5arg2, r5arg];
->r5a : (((x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (<T extends Derived>(x: T, y: T) => T))[]
->[r5arg2, r5arg] : (((x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (<T extends Derived>(x: T, y: T) => T))[]
+>r5a : (<T extends Derived>(x: T, y: T) => T)[]
+>[r5arg2, r5arg] : (<T extends Derived>(x: T, y: T) => T)[]
 >r5arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r5arg : <T extends Derived>(x: T, y: T) => T
 
     var r5b = [r5arg, r5arg2];
->r5b : ((<T extends Derived>(x: T, y: T) => T) | ((x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
->[r5arg, r5arg2] : ((<T extends Derived>(x: T, y: T) => T) | ((x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
+>r5b : (<T extends Derived>(x: T, y: T) => T)[]
+>[r5arg, r5arg2] : (<T extends Derived>(x: T, y: T) => T)[]
 >r5arg : <T extends Derived>(x: T, y: T) => T
 >r5arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
@@ -478,14 +478,14 @@ module Errors {
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 
     var r6a = [r6arg2, r6arg];
->r6a : ((<T extends Derived2[]>(x: Base[], y: Base[]) => T) | ((x: Base[], y: Derived2[]) => Derived[]))[]
->[r6arg2, r6arg] : ((<T extends Derived2[]>(x: Base[], y: Base[]) => T) | ((x: Base[], y: Derived2[]) => Derived[]))[]
+>r6a : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg2, r6arg] : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg2 : <T extends Derived2[]>(x: Base[], y: Base[]) => T
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 
     var r6b = [r6arg, r6arg2];
->r6b : (((x: Base[], y: Derived2[]) => Derived[]) | (<T extends Derived2[]>(x: Base[], y: Base[]) => T))[]
->[r6arg, r6arg2] : (((x: Base[], y: Derived2[]) => Derived[]) | (<T extends Derived2[]>(x: Base[], y: Base[]) => T))[]
+>r6b : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg, r6arg2] : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 >r6arg2 : <T extends Derived2[]>(x: Base[], y: Base[]) => T
 
@@ -517,14 +517,14 @@ module Errors {
 >r7arg : <T>(x: { a: T; b: T; }) => T
 
     var r7a = [r7arg2, r7arg];
->r7a : (((x: { a: string; b: number; }) => number) | (<T>(x: { a: T; b: T; }) => T))[]
->[r7arg2, r7arg] : (((x: { a: string; b: number; }) => number) | (<T>(x: { a: T; b: T; }) => T))[]
+>r7a : (<T>(x: { a: T; b: T; }) => T)[]
+>[r7arg2, r7arg] : (<T>(x: { a: T; b: T; }) => T)[]
 >r7arg2 : (x: { a: string; b: number; }) => number
 >r7arg : <T>(x: { a: T; b: T; }) => T
 
     var r7b = [r7arg, r7arg2];
->r7b : ((<T>(x: { a: T; b: T; }) => T) | ((x: { a: string; b: number; }) => number))[]
->[r7arg, r7arg2] : ((<T>(x: { a: T; b: T; }) => T) | ((x: { a: string; b: number; }) => number))[]
+>r7b : (<T>(x: { a: T; b: T; }) => T)[]
+>[r7arg, r7arg2] : (<T>(x: { a: T; b: T; }) => T)[]
 >r7arg : <T>(x: { a: T; b: T; }) => T
 >r7arg2 : (x: { a: string; b: number; }) => number
 
@@ -547,14 +547,14 @@ module Errors {
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7d = [r7arg2, r7arg3];
->r7d : (((x: { a: string; b: number; }) => number) | (<T extends Base>(x: { a: T; b: T; }) => number))[]
->[r7arg2, r7arg3] : (((x: { a: string; b: number; }) => number) | (<T extends Base>(x: { a: T; b: T; }) => number))[]
+>r7d : ((x: { a: string; b: number; }) => number)[]
+>[r7arg2, r7arg3] : ((x: { a: string; b: number; }) => number)[]
 >r7arg2 : (x: { a: string; b: number; }) => number
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : ((<T extends Base>(x: { a: T; b: T; }) => number) | ((x: { a: string; b: number; }) => number))[]
->[r7arg3, r7arg2] : ((<T extends Base>(x: { a: T; b: T; }) => number) | ((x: { a: string; b: number; }) => number))[]
+>r7e : (<T extends Base>(x: { a: T; b: T; }) => number)[]
+>[r7arg3, r7arg2] : (<T extends Base>(x: { a: T; b: T; }) => number)[]
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.types b/tests/baselines/reference/subtypingWithCallSignatures4.types
index 830f065f556..f490f787878 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures4.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures4.types
@@ -317,14 +317,14 @@ var r3 = foo3(r3arg);
 >r3arg : <T>(x: T) => T
 
 var r3a = [r3arg, r3arg2];
->r3a : ((<T>(x: T) => T) | (<T>(x: T) => void))[]
->[r3arg, r3arg2] : ((<T>(x: T) => T) | (<T>(x: T) => void))[]
+>r3a : (<T>(x: T) => T)[]
+>[r3arg, r3arg2] : (<T>(x: T) => T)[]
 >r3arg : <T>(x: T) => T
 >r3arg2 : <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : ((<T>(x: T) => void) | (<T>(x: T) => T))[]
->[r3arg2, r3arg] : ((<T>(x: T) => void) | (<T>(x: T) => T))[]
+>r3b : (<T>(x: T) => void)[]
+>[r3arg2, r3arg] : (<T>(x: T) => void)[]
 >r3arg2 : <T>(x: T) => void
 >r3arg : <T>(x: T) => T
 
@@ -447,14 +447,14 @@ var r6 = foo6(r6arg);
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
 var r6a = [r6arg, r6arg2];
->r6a : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => T) | (<T extends Base>(x: (arg: T) => Derived) => T))[]
->[r6arg, r6arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U) => T) | (<T extends Base>(x: (arg: T) => Derived) => T))[]
+>r6a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg, r6arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : ((<T extends Base>(x: (arg: T) => Derived) => T) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => T))[]
->[r6arg2, r6arg] : ((<T extends Base>(x: (arg: T) => Derived) => T) | (<T extends Base, U extends Derived>(x: (arg: T) => U) => T))[]
+>r6b : (<T extends Base>(x: (arg: T) => Derived) => T)[]
+>[r6arg2, r6arg] : (<T extends Base>(x: (arg: T) => Derived) => T)[]
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
@@ -498,14 +498,14 @@ var r11 = foo11(r11arg);
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
 var r11a = [r11arg, r11arg2];
->r11a : ((<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base) | (<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base))[]
->[r11arg, r11arg2] : ((<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base) | (<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base))[]
+>r11a : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg, r11arg2] : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : ((<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base) | (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base))[]
->[r11arg2, r11arg] : ((<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base) | (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base))[]
+>r11b : (<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base)[]
+>[r11arg2, r11arg] : (<T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base)[]
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -543,14 +543,14 @@ var r15 = foo15(r15arg);
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 
 var r15a = [r15arg, r15arg2];
->r15a : ((<U, V>(x: { a: U; b: V; }) => U[]) | (<T>(x: { a: T; b: T; }) => T[]))[]
->[r15arg, r15arg2] : ((<U, V>(x: { a: U; b: V; }) => U[]) | (<T>(x: { a: T; b: T; }) => T[]))[]
+>r15a : (<U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg, r15arg2] : (<U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : ((<T>(x: { a: T; b: T; }) => T[]) | (<U, V>(x: { a: U; b: V; }) => U[]))[]
->[r15arg2, r15arg] : ((<T>(x: { a: T; b: T; }) => T[]) | (<U, V>(x: { a: U; b: V; }) => U[]))[]
+>r15b : (<T>(x: { a: T; b: T; }) => T[])[]
+>[r15arg2, r15arg] : (<T>(x: { a: T; b: T; }) => T[])[]
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.types b/tests/baselines/reference/subtypingWithConstructSignatures2.types
index f00ad0332ca..c66d6055558 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures2.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures2.types
@@ -326,14 +326,14 @@ var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
 >r1arg1 : new <T>(x: T) => T[]
 
 var r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions
->r1a : ((new (x: number) => number[]) | (new <T>(x: T) => T[]))[]
->[r1arg2, r1arg1] : ((new (x: number) => number[]) | (new <T>(x: T) => T[]))[]
+>r1a : (new <T>(x: T) => T[])[]
+>[r1arg2, r1arg1] : (new <T>(x: T) => T[])[]
 >r1arg2 : new (x: number) => number[]
 >r1arg1 : new <T>(x: T) => T[]
 
 var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
->r1b : ((new <T>(x: T) => T[]) | (new (x: number) => number[]))[]
->[r1arg1, r1arg2] : ((new <T>(x: T) => T[]) | (new (x: number) => number[]))[]
+>r1b : (new <T>(x: T) => T[])[]
+>[r1arg1, r1arg2] : (new <T>(x: T) => T[])[]
 >r1arg1 : new <T>(x: T) => T[]
 >r1arg2 : new (x: number) => number[]
 
@@ -354,14 +354,14 @@ var r2 = foo2(r2arg1);
 >r2arg1 : new <T>(x: T) => string[]
 
 var r2a = [r2arg1, r2arg2];
->r2a : ((new <T>(x: T) => string[]) | (new (x: number) => string[]))[]
->[r2arg1, r2arg2] : ((new <T>(x: T) => string[]) | (new (x: number) => string[]))[]
+>r2a : (new <T>(x: T) => string[])[]
+>[r2arg1, r2arg2] : (new <T>(x: T) => string[])[]
 >r2arg1 : new <T>(x: T) => string[]
 >r2arg2 : new (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : ((new (x: number) => string[]) | (new <T>(x: T) => string[]))[]
->[r2arg2, r2arg1] : ((new (x: number) => string[]) | (new <T>(x: T) => string[]))[]
+>r2b : (new (x: number) => string[])[]
+>[r2arg2, r2arg1] : (new (x: number) => string[])[]
 >r2arg2 : new (x: number) => string[]
 >r2arg1 : new <T>(x: T) => string[]
 
@@ -383,14 +383,14 @@ var r3 = foo3(r3arg1);
 >r3arg1 : new <T>(x: T) => T
 
 var r3a = [r3arg1, r3arg2];
->r3a : ((new <T>(x: T) => T) | (new (x: number) => void))[]
->[r3arg1, r3arg2] : ((new <T>(x: T) => T) | (new (x: number) => void))[]
+>r3a : (new <T>(x: T) => T)[]
+>[r3arg1, r3arg2] : (new <T>(x: T) => T)[]
 >r3arg1 : new <T>(x: T) => T
 >r3arg2 : new (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : ((new (x: number) => void) | (new <T>(x: T) => T))[]
->[r3arg2, r3arg1] : ((new (x: number) => void) | (new <T>(x: T) => T))[]
+>r3b : (new (x: number) => void)[]
+>[r3arg2, r3arg1] : (new (x: number) => void)[]
 >r3arg2 : new (x: number) => void
 >r3arg1 : new <T>(x: T) => T
 
@@ -416,14 +416,14 @@ var r4 = foo4(r4arg1); // any
 >r4arg1 : new <T, U>(x: T, y: U) => T
 
 var r4a = [r4arg1, r4arg2];
->r4a : ((new <T, U>(x: T, y: U) => T) | (new (x: string, y: number) => string))[]
->[r4arg1, r4arg2] : ((new <T, U>(x: T, y: U) => T) | (new (x: string, y: number) => string))[]
+>r4a : (new <T, U>(x: T, y: U) => T)[]
+>[r4arg1, r4arg2] : (new <T, U>(x: T, y: U) => T)[]
 >r4arg1 : new <T, U>(x: T, y: U) => T
 >r4arg2 : new (x: string, y: number) => string
 
 var r4b = [r4arg2, r4arg1];
->r4b : ((new (x: string, y: number) => string) | (new <T, U>(x: T, y: U) => T))[]
->[r4arg2, r4arg1] : ((new (x: string, y: number) => string) | (new <T, U>(x: T, y: U) => T))[]
+>r4b : (new <T, U>(x: T, y: U) => T)[]
+>[r4arg2, r4arg1] : (new <T, U>(x: T, y: U) => T)[]
 >r4arg2 : new (x: string, y: number) => string
 >r4arg1 : new <T, U>(x: T, y: U) => T
 
@@ -449,14 +449,14 @@ var r5 = foo5(r5arg1); // any
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 
 var r5a = [r5arg1, r5arg2];
->r5a : ((new <T, U>(x: new (arg: T) => U) => T) | (new (x: new (arg: string) => number) => string))[]
->[r5arg1, r5arg2] : ((new <T, U>(x: new (arg: T) => U) => T) | (new (x: new (arg: string) => number) => string))[]
+>r5a : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg1, r5arg2] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 >r5arg2 : new (x: new (arg: string) => number) => string
 
 var r5b = [r5arg2, r5arg1];
->r5b : ((new (x: new (arg: string) => number) => string) | (new <T, U>(x: new (arg: T) => U) => T))[]
->[r5arg2, r5arg1] : ((new (x: new (arg: string) => number) => string) | (new <T, U>(x: new (arg: T) => U) => T))[]
+>r5b : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg2, r5arg1] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg2 : new (x: new (arg: string) => number) => string
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 
@@ -487,14 +487,14 @@ var r6 = foo6(r6arg1); // any
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
 var r6a = [r6arg1, r6arg2];
->r6a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T) | (new (x: new (arg: Base) => Derived) => Base))[]
->[r6arg1, r6arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T) | (new (x: new (arg: Base) => Derived) => Base))[]
+>r6a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg1, r6arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 >r6arg2 : new (x: new (arg: Base) => Derived) => Base
 
 var r6b = [r6arg2, r6arg1];
->r6b : ((new (x: new (arg: Base) => Derived) => Base) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T))[]
->[r6arg2, r6arg1] : ((new (x: new (arg: Base) => Derived) => Base) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T))[]
+>r6b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg2, r6arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg2 : new (x: new (arg: Base) => Derived) => Base
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
@@ -529,14 +529,14 @@ var r7 = foo7(r7arg1); // any
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 
 var r7a = [r7arg1, r7arg2];
->r7a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived) => new (r: Base) => Derived))[]
->[r7arg1, r7arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived) => new (r: Base) => Derived))[]
+>r7a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
+>[r7arg1, r7arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 >r7arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived
 
 var r7b = [r7arg2, r7arg1];
->r7b : ((new (x: new (arg: Base) => Derived) => new (r: Base) => Derived) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U))[]
->[r7arg2, r7arg1] : ((new (x: new (arg: Base) => Derived) => new (r: Base) => Derived) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U))[]
+>r7b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
+>[r7arg2, r7arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
 >r7arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 
@@ -579,14 +579,14 @@ var r8 = foo8(r8arg1); // any
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 
 var r8a = [r8arg1, r8arg2];
->r8a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
->[r8arg1, r8arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
+>r8a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
+>[r8arg1, r8arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 >r8arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
 var r8b = [r8arg2, r8arg1];
->r8b : ((new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U))[]
->[r8arg2, r8arg1] : ((new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U))[]
+>r8b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
+>[r8arg2, r8arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
 >r8arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 
@@ -662,14 +662,14 @@ var r10 = foo10(r10arg1); // any
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 
 var r10a = [r10arg1, r10arg2];
->r10a : ((new <T extends Derived>(...x: T[]) => T) | (new (...x: Derived[]) => Derived))[]
->[r10arg1, r10arg2] : ((new <T extends Derived>(...x: T[]) => T) | (new (...x: Derived[]) => Derived))[]
+>r10a : (new <T extends Derived>(...x: T[]) => T)[]
+>[r10arg1, r10arg2] : (new <T extends Derived>(...x: T[]) => T)[]
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 >r10arg2 : new (...x: Derived[]) => Derived
 
 var r10b = [r10arg2, r10arg1];
->r10b : ((new (...x: Derived[]) => Derived) | (new <T extends Derived>(...x: T[]) => T))[]
->[r10arg2, r10arg1] : ((new (...x: Derived[]) => Derived) | (new <T extends Derived>(...x: T[]) => T))[]
+>r10b : (new <T extends Derived>(...x: T[]) => T)[]
+>[r10arg2, r10arg1] : (new <T extends Derived>(...x: T[]) => T)[]
 >r10arg2 : new (...x: Derived[]) => Derived
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 
@@ -699,14 +699,14 @@ var r11 = foo11(r11arg1); // any
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 
 var r11a = [r11arg1, r11arg2];
->r11a : ((new <T extends Base>(x: T, y: T) => T) | (new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
->[r11arg1, r11arg2] : ((new <T extends Base>(x: T, y: T) => T) | (new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
+>r11a : (new <T extends Base>(x: T, y: T) => T)[]
+>[r11arg1, r11arg2] : (new <T extends Base>(x: T, y: T) => T)[]
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 >r11arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var r11b = [r11arg2, r11arg1];
->r11b : ((new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (new <T extends Base>(x: T, y: T) => T))[]
->[r11arg2, r11arg1] : ((new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (new <T extends Base>(x: T, y: T) => T))[]
+>r11b : (new <T extends Base>(x: T, y: T) => T)[]
+>[r11arg2, r11arg1] : (new <T extends Base>(x: T, y: T) => T)[]
 >r11arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 
@@ -741,14 +741,14 @@ var r12 = foo12(r12arg1); // any
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 
 var r12a = [r12arg1, r12arg2];
->r12a : ((new <T extends Base[]>(x: Base[], y: T) => Derived[]) | (new (x: Base[], y: Derived2[]) => Derived[]))[]
->[r12arg1, r12arg2] : ((new <T extends Base[]>(x: Base[], y: T) => Derived[]) | (new (x: Base[], y: Derived2[]) => Derived[]))[]
+>r12a : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg1, r12arg2] : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : ((new (x: Base[], y: Derived2[]) => Derived[]) | (new <T extends Base[]>(x: Base[], y: T) => Derived[]))[]
->[r12arg2, r12arg1] : ((new (x: Base[], y: Derived2[]) => Derived[]) | (new <T extends Base[]>(x: Base[], y: T) => Derived[]))[]
+>r12b : (new (x: Base[], y: Derived2[]) => Derived[])[]
+>[r12arg2, r12arg1] : (new (x: Base[], y: Derived2[]) => Derived[])[]
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 
@@ -782,14 +782,14 @@ var r13 = foo13(r13arg1); // any
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 
 var r13a = [r13arg1, r13arg2];
->r13a : ((new <T extends Derived[]>(x: Base[], y: T) => T) | (new (x: Base[], y: Derived[]) => Derived[]))[]
->[r13arg1, r13arg2] : ((new <T extends Derived[]>(x: Base[], y: T) => T) | (new (x: Base[], y: Derived[]) => Derived[]))[]
+>r13a : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg1, r13arg2] : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 >r13arg2 : new (x: Base[], y: Derived[]) => Derived[]
 
 var r13b = [r13arg2, r13arg1];
->r13b : ((new (x: Base[], y: Derived[]) => Derived[]) | (new <T extends Derived[]>(x: Base[], y: T) => T))[]
->[r13arg2, r13arg1] : ((new (x: Base[], y: Derived[]) => Derived[]) | (new <T extends Derived[]>(x: Base[], y: T) => T))[]
+>r13b : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg2, r13arg1] : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg2 : new (x: Base[], y: Derived[]) => Derived[]
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 
@@ -817,14 +817,14 @@ var r14 = foo14(r14arg1); // any
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 
 var r14a = [r14arg1, r14arg2];
->r14a : ((new <T>(x: { a: T; b: T; }) => T) | (new (x: { a: string; b: number; }) => Object))[]
->[r14arg1, r14arg2] : ((new <T>(x: { a: T; b: T; }) => T) | (new (x: { a: string; b: number; }) => Object))[]
+>r14a : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r14arg1, r14arg2] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 >r14arg2 : new (x: { a: string; b: number; }) => Object
 
 var r14b = [r14arg2, r14arg1];
->r14b : ((new (x: { a: string; b: number; }) => Object) | (new <T>(x: { a: T; b: T; }) => T))[]
->[r14arg2, r14arg1] : ((new (x: { a: string; b: number; }) => Object) | (new <T>(x: { a: T; b: T; }) => T))[]
+>r14b : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r14arg2, r14arg1] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r14arg2 : new (x: { a: string; b: number; }) => Object
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.types b/tests/baselines/reference/subtypingWithConstructSignatures3.types
index b7c90d8697e..741db4f4ba6 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures3.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures3.types
@@ -224,14 +224,14 @@ module Errors {
 >r1arg1 : new <T, U>(x: T) => U[]
 
     var r1a = [r1arg2, r1arg1];
->r1a : ((new (x: number) => string[]) | (new <T, U>(x: T) => U[]))[]
->[r1arg2, r1arg1] : ((new (x: number) => string[]) | (new <T, U>(x: T) => U[]))[]
+>r1a : (new <T, U>(x: T) => U[])[]
+>[r1arg2, r1arg1] : (new <T, U>(x: T) => U[])[]
 >r1arg2 : new (x: number) => string[]
 >r1arg1 : new <T, U>(x: T) => U[]
 
     var r1b = [r1arg1, r1arg2];
->r1b : ((new <T, U>(x: T) => U[]) | (new (x: number) => string[]))[]
->[r1arg1, r1arg2] : ((new <T, U>(x: T) => U[]) | (new (x: number) => string[]))[]
+>r1b : (new <T, U>(x: T) => U[])[]
+>[r1arg1, r1arg2] : (new <T, U>(x: T) => U[])[]
 >r1arg1 : new <T, U>(x: T) => U[]
 >r1arg2 : new (x: number) => string[]
 
@@ -268,14 +268,14 @@ module Errors {
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 
     var r2a = [r2arg2, r2arg1];
->r2a : ((new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2) | (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V))[]
->[r2arg2, r2arg1] : ((new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2) | (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V))[]
+>r2a : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
+>[r2arg2, r2arg1] : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
 >r2arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 
     var r2b = [r2arg1, r2arg2];
->r2b : ((new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V) | (new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2))[]
->[r2arg1, r2arg2] : ((new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V) | (new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2))[]
+>r2b : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
+>[r2arg1, r2arg2] : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 >r2arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2
 
@@ -350,14 +350,14 @@ module Errors {
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 
     var r4a = [r4arg2, r4arg1];
->r4a : ((new (...x: Base[]) => Base) | (new <T extends Derived>(...x: T[]) => T))[]
->[r4arg2, r4arg1] : ((new (...x: Base[]) => Base) | (new <T extends Derived>(...x: T[]) => T))[]
+>r4a : (new <T extends Derived>(...x: T[]) => T)[]
+>[r4arg2, r4arg1] : (new <T extends Derived>(...x: T[]) => T)[]
 >r4arg2 : new (...x: Base[]) => Base
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 
     var r4b = [r4arg1, r4arg2];
->r4b : ((new <T extends Derived>(...x: T[]) => T) | (new (...x: Base[]) => Base))[]
->[r4arg1, r4arg2] : ((new <T extends Derived>(...x: T[]) => T) | (new (...x: Base[]) => Base))[]
+>r4b : (new <T extends Derived>(...x: T[]) => T)[]
+>[r4arg1, r4arg2] : (new <T extends Derived>(...x: T[]) => T)[]
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 >r4arg2 : new (...x: Base[]) => Base
 
@@ -387,14 +387,14 @@ module Errors {
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 
     var r5a = [r5arg2, r5arg1];
->r5a : ((new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (new <T extends Derived>(x: T, y: T) => T))[]
->[r5arg2, r5arg1] : ((new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base) | (new <T extends Derived>(x: T, y: T) => T))[]
+>r5a : (new <T extends Derived>(x: T, y: T) => T)[]
+>[r5arg2, r5arg1] : (new <T extends Derived>(x: T, y: T) => T)[]
 >r5arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 
     var r5b = [r5arg1, r5arg2];
->r5b : ((new <T extends Derived>(x: T, y: T) => T) | (new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
->[r5arg1, r5arg2] : ((new <T extends Derived>(x: T, y: T) => T) | (new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base))[]
+>r5b : (new <T extends Derived>(x: T, y: T) => T)[]
+>[r5arg1, r5arg2] : (new <T extends Derived>(x: T, y: T) => T)[]
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 >r5arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
@@ -429,14 +429,14 @@ module Errors {
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 
     var r6a = [r6arg2, r6arg1];
->r6a : ((new <T extends Derived2[]>(x: Base[], y: Base[]) => T) | (new (x: Base[], y: Derived2[]) => Derived[]))[]
->[r6arg2, r6arg1] : ((new <T extends Derived2[]>(x: Base[], y: Base[]) => T) | (new (x: Base[], y: Derived2[]) => Derived[]))[]
+>r6a : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg2, r6arg1] : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg2 : new <T extends Derived2[]>(x: Base[], y: Base[]) => T
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 
     var r6b = [r6arg1, r6arg2];
->r6b : ((new (x: Base[], y: Derived2[]) => Derived[]) | (new <T extends Derived2[]>(x: Base[], y: Base[]) => T))[]
->[r6arg1, r6arg2] : ((new (x: Base[], y: Derived2[]) => Derived[]) | (new <T extends Derived2[]>(x: Base[], y: Base[]) => T))[]
+>r6b : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg1, r6arg2] : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 >r6arg2 : new <T extends Derived2[]>(x: Base[], y: Base[]) => T
 
@@ -463,14 +463,14 @@ module Errors {
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 
     var r7a = [r7arg2, r7arg1];
->r7a : ((new (x: { a: string; b: number; }) => number) | (new <T>(x: { a: T; b: T; }) => T))[]
->[r7arg2, r7arg1] : ((new (x: { a: string; b: number; }) => number) | (new <T>(x: { a: T; b: T; }) => T))[]
+>r7a : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r7arg2, r7arg1] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r7arg2 : new (x: { a: string; b: number; }) => number
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 
     var r7b = [r7arg1, r7arg2];
->r7b : ((new <T>(x: { a: T; b: T; }) => T) | (new (x: { a: string; b: number; }) => number))[]
->[r7arg1, r7arg2] : ((new <T>(x: { a: T; b: T; }) => T) | (new (x: { a: string; b: number; }) => number))[]
+>r7b : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r7arg1, r7arg2] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 >r7arg2 : new (x: { a: string; b: number; }) => number
 
@@ -491,14 +491,14 @@ module Errors {
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7d = [r7arg2, r7arg3];
->r7d : ((new (x: { a: string; b: number; }) => number) | (new <T extends Base>(x: { a: T; b: T; }) => number))[]
->[r7arg2, r7arg3] : ((new (x: { a: string; b: number; }) => number) | (new <T extends Base>(x: { a: T; b: T; }) => number))[]
+>r7d : (new (x: { a: string; b: number; }) => number)[]
+>[r7arg2, r7arg3] : (new (x: { a: string; b: number; }) => number)[]
 >r7arg2 : new (x: { a: string; b: number; }) => number
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : ((new <T extends Base>(x: { a: T; b: T; }) => number) | (new (x: { a: string; b: number; }) => number))[]
->[r7arg3, r7arg2] : ((new <T extends Base>(x: { a: T; b: T; }) => number) | (new (x: { a: string; b: number; }) => number))[]
+>r7e : (new <T extends Base>(x: { a: T; b: T; }) => number)[]
+>[r7arg3, r7arg2] : (new <T extends Base>(x: { a: T; b: T; }) => number)[]
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : new (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures4.types b/tests/baselines/reference/subtypingWithConstructSignatures4.types
index 328dadad41c..932adcb7368 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures4.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures4.types
@@ -301,14 +301,14 @@ var r3 = foo3(r3arg);
 >r3arg : new <T>(x: T) => T
 
 var r3a = [r3arg, r3arg2];
->r3a : ((new <T>(x: T) => T) | (new <T>(x: T) => void))[]
->[r3arg, r3arg2] : ((new <T>(x: T) => T) | (new <T>(x: T) => void))[]
+>r3a : (new <T>(x: T) => T)[]
+>[r3arg, r3arg2] : (new <T>(x: T) => T)[]
 >r3arg : new <T>(x: T) => T
 >r3arg2 : new <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : ((new <T>(x: T) => void) | (new <T>(x: T) => T))[]
->[r3arg2, r3arg] : ((new <T>(x: T) => void) | (new <T>(x: T) => T))[]
+>r3b : (new <T>(x: T) => void)[]
+>[r3arg2, r3arg] : (new <T>(x: T) => void)[]
 >r3arg2 : new <T>(x: T) => void
 >r3arg : new <T>(x: T) => T
 
@@ -415,14 +415,14 @@ var r6 = foo6(r6arg);
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
 var r6a = [r6arg, r6arg2];
->r6a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T) | (new <T extends Base>(x: new (arg: T) => Derived) => T))[]
->[r6arg, r6arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T) | (new <T extends Base>(x: new (arg: T) => Derived) => T))[]
+>r6a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg, r6arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : ((new <T extends Base>(x: new (arg: T) => Derived) => T) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T))[]
->[r6arg2, r6arg] : ((new <T extends Base>(x: new (arg: T) => Derived) => T) | (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T))[]
+>r6b : (new <T extends Base>(x: new (arg: T) => Derived) => T)[]
+>[r6arg2, r6arg] : (new <T extends Base>(x: new (arg: T) => Derived) => T)[]
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
@@ -460,14 +460,14 @@ var r11 = foo11(r11arg);
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
 var r11a = [r11arg, r11arg2];
->r11a : ((new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base) | (new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base))[]
->[r11arg, r11arg2] : ((new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base) | (new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base))[]
+>r11a : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg, r11arg2] : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : ((new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base) | (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base))[]
->[r11arg2, r11arg] : ((new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base) | (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base))[]
+>r11b : (new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base)[]
+>[r11arg2, r11arg] : (new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base)[]
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -499,14 +499,14 @@ var r15 = foo15(r15arg);
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 
 var r15a = [r15arg, r15arg2];
->r15a : ((new <U, V>(x: { a: U; b: V; }) => U[]) | (new <T>(x: { a: T; b: T; }) => T[]))[]
->[r15arg, r15arg2] : ((new <U, V>(x: { a: U; b: V; }) => U[]) | (new <T>(x: { a: T; b: T; }) => T[]))[]
+>r15a : (new <U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg, r15arg2] : (new <U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : ((new <T>(x: { a: T; b: T; }) => T[]) | (new <U, V>(x: { a: U; b: V; }) => U[]))[]
->[r15arg2, r15arg] : ((new <T>(x: { a: T; b: T; }) => T[]) | (new <U, V>(x: { a: U; b: V; }) => U[]))[]
+>r15b : (new <T>(x: { a: T; b: T; }) => T[])[]
+>[r15arg2, r15arg] : (new <T>(x: { a: T; b: T; }) => T[])[]
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality.types b/tests/baselines/reference/subtypingWithObjectMembersOptionality.types
index 0d55d78e266..815f2d60740 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality.types
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality.types
@@ -85,8 +85,8 @@ var b = { Foo: <Derived>null };
 >null : null
 
 var r = true ? a : b;
->r : { Foo?: Base; } | { Foo: Derived; }
->true ? a : b : { Foo?: Base; } | { Foo: Derived; }
+>r : { Foo?: Base; }
+>true ? a : b : { Foo?: Base; }
 >true : boolean
 >a : { Foo?: Base; }
 >b : { Foo: Derived; }
@@ -156,8 +156,8 @@ module TwoLevels {
 >null : null
 
     var r = true ? a : b;
->r : { Foo?: Base; } | { Foo: Derived2; }
->true ? a : b : { Foo?: Base; } | { Foo: Derived2; }
+>r : { Foo?: Base; }
+>true ? a : b : { Foo?: Base; }
 >true : boolean
 >a : { Foo?: Base; }
 >b : { Foo: Derived2; }
diff --git a/tests/baselines/reference/symbolType11.types b/tests/baselines/reference/symbolType11.types
index a7de59a11b7..b251db43301 100644
--- a/tests/baselines/reference/symbolType11.types
+++ b/tests/baselines/reference/symbolType11.types
@@ -33,7 +33,7 @@ s || 1;
 >1 : number
 
 ({}) || s;
->({}) || s : {} | symbol
+>({}) || s : {}
 >({}) : {}
 >{} : {}
 >s : symbol
diff --git a/tests/baselines/reference/typeGuardsInConditionalExpression.types b/tests/baselines/reference/typeGuardsInConditionalExpression.types
index ef048fb8562..493a8c0a31a 100644
--- a/tests/baselines/reference/typeGuardsInConditionalExpression.types
+++ b/tests/baselines/reference/typeGuardsInConditionalExpression.types
@@ -363,9 +363,9 @@ function foo12(x: number | string | boolean) {
 >10 : number
 >x.toString().length : number
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 >length : number
 
         : ((b = x) // x is number | boolean | string  - changed in true branch
diff --git a/tests/baselines/reference/typeGuardsInIfStatement.types b/tests/baselines/reference/typeGuardsInIfStatement.types
index 8e22d4ba3e0..0095a7cc768 100644
--- a/tests/baselines/reference/typeGuardsInIfStatement.types
+++ b/tests/baselines/reference/typeGuardsInIfStatement.types
@@ -333,9 +333,9 @@ function foo11(x: number | string | boolean) {
 >10 && x.toString() : string
 >10 : number
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 
             )
             : (
@@ -348,9 +348,9 @@ function foo11(x: number | string | boolean) {
 >x && x.toString() : string
 >x : number | string | boolean
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 
             );
     }
@@ -369,9 +369,9 @@ function foo12(x: number | string | boolean) {
 
         return x.toString(); // string | number | boolean - x changed in else branch
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
     }
     else {
         x = 10;
diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.types b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.types
index b69c80ff55a..22d390618c1 100644
--- a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.types
+++ b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.types
@@ -180,9 +180,9 @@ function foo7(x: number | string | boolean) {
 >10 && x.toString() : string
 >10 : number
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 
         // do not change value
         : (y = x && x.toString()))); // number | boolean | string
@@ -192,9 +192,9 @@ function foo7(x: number | string | boolean) {
 >x && x.toString() : string
 >x : number | string | boolean
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 }
 function foo8(x: number | string) {
 >foo8 : (x: number | string) => number
diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.types b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.types
index b2f5401e843..38d9a723d3a 100644
--- a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.types
+++ b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.types
@@ -180,9 +180,9 @@ function foo7(x: number | string | boolean) {
 >10 && x.toString() : string
 >10 : number
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 
         // do not change value
         : (y = x && x.toString()))); // number | boolean | string
@@ -192,9 +192,9 @@ function foo7(x: number | string | boolean) {
 >x && x.toString() : string
 >x : number | string | boolean
 >x.toString() : string
->x.toString : ((radix?: number) => string) | (() => string)
+>x.toString : (radix?: number) => string
 >x : number | string | boolean
->toString : ((radix?: number) => string) | (() => string)
+>toString : (radix?: number) => string
 }
 function foo8(x: number | string) {
 >foo8 : (x: number | string) => boolean | number
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 31b01c5f76e..7fe233c4490 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -547,7 +547,7 @@ _.flatten([1, [2], [3, [[4]]]]);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : (number | number[] | (number | number[][])[])[]
+>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
 >1 : number
 >[2] : number[]
 >2 : number
@@ -562,7 +562,7 @@ _.flatten([1, [2], [3, [[4]]]], true);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : (number | number[] | (number | number[][])[])[]
+>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
 >1 : number
 >[2] : number[]
 >2 : number
diff --git a/tests/baselines/reference/unionTypeFromArrayLiteral.types b/tests/baselines/reference/unionTypeFromArrayLiteral.types
index 604925eb25f..63aefdd214c 100644
--- a/tests/baselines/reference/unionTypeFromArrayLiteral.types
+++ b/tests/baselines/reference/unionTypeFromArrayLiteral.types
@@ -83,15 +83,15 @@ var arr6 = [c, d];  // (C | D)[]
 >d : D
 
 var arr7 = [c, d, e]; // (C | D)[]
->arr7 : (C | D | E)[]
->[c, d, e] : (C | D | E)[]
+>arr7 : (C | D)[]
+>[c, d, e] : (C | D)[]
 >c : C
 >d : D
 >e : E
 
 var arr8 = [c, e]; // C[]
->arr8 : (C | E)[]
->[c, e] : (C | E)[]
+>arr8 : C[]
+>[c, e] : C[]
 >c : C
 >e : E
 
diff --git a/tests/baselines/reference/unionTypeReduction.types b/tests/baselines/reference/unionTypeReduction.types
index 8ecd9b33fb5..073d690162a 100644
--- a/tests/baselines/reference/unionTypeReduction.types
+++ b/tests/baselines/reference/unionTypeReduction.types
@@ -25,8 +25,8 @@ var e1: I2 | I3;
 >I3 : I3
 
 var e2 = i2 || i3;  // Type of e2 immediately reduced to I3
->e2 : I2 | I3
->i2 || i3 : I2 | I3
+>e2 : I3
+>i2 || i3 : I3
 >i2 : I2
 >i3 : I3
 
@@ -38,5 +38,5 @@ var r1 = e1();  // Type of e1 reduced to I3 upon accessing property or signature
 var r2 = e2();
 >r2 : number
 >e2() : number
->e2 : I2 | I3
+>e2 : I3
 
diff --git a/tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction1.types b/tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction1.types
index f609301c19c..caaa02b7b53 100644
--- a/tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction1.types
+++ b/tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction1.types
@@ -39,7 +39,7 @@ var t: Class | Property;
 >Property : Property
 
 t.parent;
->t.parent : Namespace | Module | Class
+>t.parent : Namespace | Class
 >t : Class | Property
->parent : Namespace | Module | Class
+>parent : Namespace | Class
 

From 2611607159a8887bf1b3a2579366f84fa3c8a650 Mon Sep 17 00:00:00 2001
From: Tien Nguyen <tihoanh@microsoft.com>
Date: Fri, 28 Aug 2015 16:01:04 -0700
Subject: [PATCH 09/17] Reformat some code.

---
 src/server/editorServices.ts | 62 ++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index dd29d3cf2c9..76bc586b8bb 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -614,30 +614,30 @@ namespace ts.server {
             }
             this.configuredProjects = configuredProjects;
         }
-        
-        removeConfiguredProject(project: Project) {
-                project.projectFileWatcher.close();
-                this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
 
-                let fileNames = project.getFileNames();
-                for (let fileName of fileNames) {
-                    let info = this.getScriptInfo(fileName);
-                    if (info.defaultProject == project){
-                        info.defaultProject = undefined;
-                    }
+        removeConfiguredProject(project: Project) {
+            project.projectFileWatcher.close();
+            this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
+
+            let fileNames = project.getFileNames();
+            for (let fileName of fileNames) {
+                let info = this.getScriptInfo(fileName);
+                if (info.defaultProject == project) {
+                    info.defaultProject = undefined;
                 }
+            }
         }
 
         setConfiguredProjectRoot(info: ScriptInfo) {
-             for (var i = 0, len = this.configuredProjects.length; i < len; i++) {
-                 let configuredProject = this.configuredProjects[i];
-                 if (configuredProject.isRoot(info)) {
-                     info.defaultProject = configuredProject;
-                     configuredProject.addOpenRef();
-                     return true;
-                 }
-             }
-             return false;
+            for (var i = 0, len = this.configuredProjects.length; i < len; i++) {
+                let configuredProject = this.configuredProjects[i];
+                if (configuredProject.isRoot(info)) {
+                    info.defaultProject = configuredProject;
+                    configuredProject.addOpenRef();
+                    return true;
+                }
+            }
+            return false;
         }
 
         addOpenFile(info: ScriptInfo) {
@@ -785,7 +785,7 @@ namespace ts.server {
         updateProjectStructure() {
             this.log("updating project structure from ...", "Info");
             this.printProjects();
-            
+
             let unattachedOpenFiles: ScriptInfo[] = [];
             let openFileRootsConfigured: ScriptInfo[] = [];
             for (let info of this.openFileRootsConfigured) {
@@ -921,10 +921,10 @@ namespace ts.server {
             this.printProjects();
             return info;
         }
-        
+
         openOrUpdateConfiguredProjectForFile(fileName: string) {
             let searchPath = ts.normalizePath(getDirectoryPath(fileName));
-            this.log("Search path: " + searchPath,"Info");
+            this.log("Search path: " + searchPath, "Info");
             let configFileName = this.findConfigFile(searchPath);
             if (configFileName) {
                 this.log("Config file name: " + configFileName, "Info");
@@ -935,7 +935,7 @@ namespace ts.server {
                         this.log("Error opening config file " + configFileName + " " + configResult.errorMsg);
                     }
                     else {
-                        this.log("Opened configuration file " + configFileName,"Info");
+                        this.log("Opened configuration file " + configFileName, "Info");
                         this.configuredProjects.push(configResult.project);
                     }
                 }
@@ -1000,7 +1000,7 @@ namespace ts.server {
             for (var i = 0, len = this.configuredProjects.length; i < len; i++) {
                 var project = this.configuredProjects[i];
                 project.updateGraph();
-                this.psLogger.info("Project (configured) " + (i+this.inferredProjects.length).toString());
+                this.psLogger.info("Project (configured) " + (i + this.inferredProjects.length).toString());
                 this.psLogger.info(project.filesToString());
                 this.psLogger.info("-----------------------------------------------");
             }
@@ -1048,10 +1048,10 @@ namespace ts.server {
             else {
                 var parsedCommandLine = ts.parseConfigFile(rawConfig.config, this.host, dirPath);
                 if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) {
-                    return { succeeded: false, error: { errorMsg: "tsconfig option errors" }};
+                    return { succeeded: false, error: { errorMsg: "tsconfig option errors" } };
                 }
                 else if (parsedCommandLine.fileNames == null) {
-                    return { succeeded: false, error: { errorMsg: "no files found" }}
+                    return { succeeded: false, error: { errorMsg: "no files found" } }
                 }
                 else {
                     var projectOptions: ProjectOptions = {
@@ -1068,7 +1068,7 @@ namespace ts.server {
             let { succeeded, projectOptions, error } = this.configFileToProjectOptions(configFilename);
             if (!succeeded) {
                 return error;
-            } 
+            }
             else {
                 let proj = this.createProject(configFilename, projectOptions);
                 for (let i = 0, len = projectOptions.files.length; i < len; i++) {
@@ -1086,7 +1086,7 @@ namespace ts.server {
                 return { success: true, project: proj };
             }
         }
-        
+
         updateConfiguredProject(project: Project) {
             if (!this.host.fileExists(project.projectFilename)) {
                 this.log("Config file deleted");
@@ -1098,16 +1098,16 @@ namespace ts.server {
                     return error;
                 }
                 else {
-                    let oldFileNames = project.compilerService.host.roots.map(info => info.fileName); 
+                    let oldFileNames = project.compilerService.host.roots.map(info => info.fileName);
                     let newFileNames = projectOptions.files;
                     let fileNamesToRemove = oldFileNames.filter(f => newFileNames.indexOf(f) < 0);
                     let fileNamesToAdd = newFileNames.filter(f => oldFileNames.indexOf(f) < 0);
-                    
+
                     for (let fileName of fileNamesToRemove) {
                         let info = this.getScriptInfo(fileName);
                         project.removeRoot(info);
                     }
-                    
+
                     for (let fileName of fileNamesToAdd) {
                         let info = this.getScriptInfo(fileName);
                         if (!info) {

From 603eb86302f5dd9336fb9907c46d513635e210c3 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 28 Aug 2015 17:39:50 -0700
Subject: [PATCH 10/17] Addressing CR feedback

---
 src/compiler/checker.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2fdeded96cf..e624eb41d86 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4081,7 +4081,7 @@ namespace ts {
         }
 
         function isSubtypeOfAny(candidate: Type, types: Type[]): boolean {
-            for (var i = 0, len = types.length; i < len; i++) {
+            for (let i = 0, len = types.length; i < len; i++) {
                 if (candidate !== types[i] && isTypeSubtypeOf(candidate, types[i])) {
                     return true;
                 }
@@ -4090,7 +4090,7 @@ namespace ts {
         }
 
         function removeSubtypes(types: Type[]) {
-            var i = types.length;
+            let i = types.length;
             while (i > 0) {
                 i--;
                 if (isSubtypeOfAny(types[i], types)) {

From c209747c6ae1b8fc4d095e5f65bb3cab5d4bfeb4 Mon Sep 17 00:00:00 2001
From: Graeme Wicksted <graeme.wicksted@gmail.com>
Date: Mon, 31 Aug 2015 10:29:58 -0400
Subject: [PATCH 11/17] Add parameters to toLocaleDateString

Also added missing option in Intl.DateTimeFormatOptions (timeZone).  Original ticket #4294
---
 src/lib/intl.d.ts | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/lib/intl.d.ts b/src/lib/intl.d.ts
index 57df70672d4..1265dc51486 100644
--- a/src/lib/intl.d.ts
+++ b/src/lib/intl.d.ts
@@ -88,6 +88,7 @@ declare module Intl {
         timeZoneName?: string;
         formatMatcher?: string;
         hour12?: boolean;
+        timeZone?: string;
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -157,17 +158,29 @@ interface Number {
 
 interface Date {
     /**
-      * Converts a date to a string by using the current or specified locale.  
+      * Converts a date and time to a string by using the current or specified locale.  
       * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }
 

From 41f37f58904b0febba49daf766b591ca0d127eba Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Mon, 31 Aug 2015 01:07:30 -0700
Subject: [PATCH 12/17] Improve error message spans when object literals have
 excess properties.

---
 src/compiler/checker.ts | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index e624eb41d86..cb53531f6b3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4593,6 +4593,16 @@ namespace ts {
             }
             return result !== Ternary.False;
 
+            function reportErrorAndTryImproveErrorNode(
+                    newErrorNode: Node,
+                    message: DiagnosticMessage,
+                    arg0?: string,
+                    arg1?: string,
+                    arg2?: string) {
+                errorNode = newErrorNode || errorNode;
+                reportError(message, arg0, arg1, arg2);
+            }
+
             function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void {
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
             }
@@ -4767,7 +4777,8 @@ namespace ts {
                 for (let prop of getPropertiesOfObjectType(source)) {
                     if (!isKnownProperty(target, prop.name)) {
                         if (reportErrors) {
-                            reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target));
+                            reportErrorAndTryImproveErrorNode(prop.valueDeclaration,
+                                Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target));
                         }
                         return true;
                     }

From f6aac04d1ebe1ac55f474a75b357a00ee96f954f Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Mon, 31 Aug 2015 01:08:09 -0700
Subject: [PATCH 13/17] Accepted baselines.

---
 tests/baselines/reference/arrayCast.errors.txt     |  4 ++--
 .../reference/arrayLiteralTypeInference.errors.txt | 14 +++++++-------
 tests/baselines/reference/arrayLiterals.errors.txt |  4 ++--
 .../reference/assignmentCompatBug2.errors.txt      | 12 ++++++------
 .../reference/assignmentCompatBug5.errors.txt      |  4 ++--
 .../reference/contextualTyping12.errors.txt        |  4 ++--
 .../reference/contextualTyping17.errors.txt        |  4 ++--
 .../reference/contextualTyping2.errors.txt         |  4 ++--
 .../reference/contextualTyping20.errors.txt        |  4 ++--
 .../reference/contextualTyping4.errors.txt         |  4 ++--
 .../reference/contextualTyping9.errors.txt         |  4 ++--
 ...HiddenBaseCallViaSuperPropertyAccess.errors.txt |  4 ++--
 .../destructuringParameterProperties5.errors.txt   |  4 ++--
 .../reference/incompatibleTypes.errors.txt         |  8 ++++----
 ...gicalOrExpressionIsContextuallyTyped.errors.txt |  4 ++--
 .../objectLitStructuralTypeMismatch.errors.txt     |  4 ++--
 ...ctLiteralFunctionArgContextualTyping.errors.txt |  8 ++++----
 ...tLiteralFunctionArgContextualTyping2.errors.txt |  8 ++++----
 ...alShorthandPropertiesAssignmentError.errors.txt |  4 ++--
 ...AssignmentErrorFromMissingIdentifier.errors.txt |  4 ++--
 ...rderMattersForSignatureGroupIdentity.errors.txt |  8 ++++----
 .../reference/switchStatements.errors.txt          |  4 ++--
 .../reference/symbolProperty21.errors.txt          | 14 +++++---------
 ...TemplateStringsTypeArgumentInference.errors.txt |  4 ++--
 ...plateStringsTypeArgumentInferenceES6.errors.txt |  4 ++--
 .../reference/typeArgInference2.errors.txt         |  4 ++--
 .../reference/typeArgumentInference.errors.txt     |  8 ++++----
 ...ArgumentInferenceConstructSignatures.errors.txt | 14 +++++++-------
 ...typeArgumentInferenceWithConstraints.errors.txt | 14 +++++++-------
 tests/baselines/reference/typeInfer1.errors.txt    |  6 +++---
 tests/baselines/reference/typeMatch2.errors.txt    | 12 ++++++------
 31 files changed, 99 insertions(+), 103 deletions(-)

diff --git a/tests/baselines/reference/arrayCast.errors.txt b/tests/baselines/reference/arrayCast.errors.txt
index 82b4b856a97..815813ea727 100644
--- a/tests/baselines/reference/arrayCast.errors.txt
+++ b/tests/baselines/reference/arrayCast.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
+tests/cases/compiler/arrayCast.ts(3,23): error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
   Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
     Object literal may only specify known properties, and 'foo' does not exist in type '{ id: number; }'.
 
@@ -7,7 +7,7 @@ tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: strin
     // Should fail. Even though the array is contextually typed with { id: number }[], it still
     // has type { foo: string }[], which is not assignable to { id: number }[].
     <{ id: number; }[]>[{ foo: "s" }];
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                          ~~~~~~~~
 !!! error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
 !!! error TS2352:   Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2352:     Object literal may only specify known properties, and 'foo' does not exist in type '{ id: number; }'.
diff --git a/tests/baselines/reference/arrayLiteralTypeInference.errors.txt b/tests/baselines/reference/arrayLiteralTypeInference.errors.txt
index 105375f2e74..a2c4597127f 100644
--- a/tests/baselines/reference/arrayLiteralTypeInference.errors.txt
+++ b/tests/baselines/reference/arrayLiteralTypeInference.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/arrayLiteralTypeInference.ts(13,5): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type 'Action[]'.
+tests/cases/compiler/arrayLiteralTypeInference.ts(14,14): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type 'Action[]'.
   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type 'Action'.
     Type '{ id: number; trueness: boolean; }' is not assignable to type 'Action'.
       Object literal may only specify known properties, and 'trueness' does not exist in type 'Action'.
-tests/cases/compiler/arrayLiteralTypeInference.ts(29,5): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+tests/cases/compiler/arrayLiteralTypeInference.ts(31,18): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
     Type '{ id: number; trueness: boolean; }' is not assignable to type '{ id: number; }'.
       Object literal may only specify known properties, and 'trueness' does not exist in type '{ id: number; }'.
@@ -22,12 +22,12 @@ tests/cases/compiler/arrayLiteralTypeInference.ts(29,5): error TS2322: Type '({
     }
     
     var x1: Action[] = [
-        ~~
+        { id: 2, trueness: false },
+                 ~~~~~~~~~~~~~~~
 !!! error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type 'Action[]'.
 !!! error TS2322:   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type 'Action'.
 !!! error TS2322:     Type '{ id: number; trueness: boolean; }' is not assignable to type 'Action'.
 !!! error TS2322:       Object literal may only specify known properties, and 'trueness' does not exist in type 'Action'.
-        { id: 2, trueness: false },
         { id: 3, name: "three" }
     ]
     
@@ -43,13 +43,13 @@ tests/cases/compiler/arrayLiteralTypeInference.ts(29,5): error TS2322: Type '({
     ]
     
     var z1: { id: number }[] =
-        ~~
+        [
+            { id: 2, trueness: false },
+                     ~~~~~~~~~~~~~~~
 !!! error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
 !!! error TS2322:   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:     Type '{ id: number; trueness: boolean; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:       Object literal may only specify known properties, and 'trueness' does not exist in type '{ id: number; }'.
-        [
-            { id: 2, trueness: false },
             { id: 3, name: "three" }
         ]
     
diff --git a/tests/baselines/reference/arrayLiterals.errors.txt b/tests/baselines/reference/arrayLiterals.errors.txt
index fd882804b8a..f5fe71b79a6 100644
--- a/tests/baselines/reference/arrayLiterals.errors.txt
+++ b/tests/baselines/reference/arrayLiterals.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts(24,5): error TS2322: Type '({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]' is not assignable to type '{ [n: number]: { a: string; b: number; }; }'.
+tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts(24,77): error TS2322: Type '({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]' is not assignable to type '{ [n: number]: { a: string; b: number; }; }'.
   Index signatures are incompatible.
     Type '{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }' is not assignable to type '{ a: string; b: number; }'.
       Type '{ a: string; b: number; c: string; }' is not assignable to type '{ a: string; b: number; }'.
@@ -30,7 +30,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts(24,5): error
     
     // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]
     var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
-        ~~~~~~~~
+                                                                                ~~~~~
 !!! error TS2322: Type '({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]' is not assignable to type '{ [n: number]: { a: string; b: number; }; }'.
 !!! error TS2322:   Index signatures are incompatible.
 !!! error TS2322:     Type '{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }' is not assignable to type '{ a: string; b: number; }'.
diff --git a/tests/baselines/reference/assignmentCompatBug2.errors.txt b/tests/baselines/reference/assignmentCompatBug2.errors.txt
index 53e12635888..29ba96e6586 100644
--- a/tests/baselines/reference/assignmentCompatBug2.errors.txt
+++ b/tests/baselines/reference/assignmentCompatBug2.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/assignmentCompatBug2.ts(1,5): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
+tests/cases/compiler/assignmentCompatBug2.ts(1,27): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
-tests/cases/compiler/assignmentCompatBug2.ts(3,1): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
+tests/cases/compiler/assignmentCompatBug2.ts(3,8): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
-tests/cases/compiler/assignmentCompatBug2.ts(5,1): error TS2322: Type '{ b: number; a: number; }' is not assignable to type '{ b: number; }'.
+tests/cases/compiler/assignmentCompatBug2.ts(5,13): error TS2322: Type '{ b: number; a: number; }' is not assignable to type '{ b: number; }'.
   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
 tests/cases/compiler/assignmentCompatBug2.ts(15,1): error TS2322: Type '{ f: (n: number) => number; g: (s: string) => number; }' is not assignable to type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'.
   Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; }'.
@@ -14,17 +14,17 @@ tests/cases/compiler/assignmentCompatBug2.ts(33,1): error TS2322: Type '{ f: (n:
 
 ==== tests/cases/compiler/assignmentCompatBug2.ts (6 errors) ====
     var b2: { b: number;} = { a: 0 }; // error
-        ~~
+                              ~~~~
 !!! error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
     b2 = { a: 0 }; // error
-    ~~
+           ~~~~
 !!! error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
     b2 = {b: 0, a: 0 };
-    ~~
+                ~~~~
 !!! error TS2322: Type '{ b: number; a: number; }' is not assignable to type '{ b: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
diff --git a/tests/baselines/reference/assignmentCompatBug5.errors.txt b/tests/baselines/reference/assignmentCompatBug5.errors.txt
index 790848babf4..1b5e3d80259 100644
--- a/tests/baselines/reference/assignmentCompatBug5.errors.txt
+++ b/tests/baselines/reference/assignmentCompatBug5.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/assignmentCompatBug5.ts(2,6): error TS2345: Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
+tests/cases/compiler/assignmentCompatBug5.ts(2,8): error TS2345: Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
 tests/cases/compiler/assignmentCompatBug5.ts(5,6): error TS2345: Argument of type 'string[]' is not assignable to parameter of type 'number[]'.
   Type 'string' is not assignable to type 'number'.
@@ -12,7 +12,7 @@ tests/cases/compiler/assignmentCompatBug5.ts(9,6): error TS2345: Argument of typ
 ==== tests/cases/compiler/assignmentCompatBug5.ts (4 errors) ====
     function foo1(x: { a: number; }) { }
     foo1({ b: 5 });
-         ~~~~~~~~
+           ~~~~
 !!! error TS2345: Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
 !!! error TS2345:   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
     
diff --git a/tests/baselines/reference/contextualTyping12.errors.txt b/tests/baselines/reference/contextualTyping12.errors.txt
index 8b079ecc5e0..22ed6ad931e 100644
--- a/tests/baselines/reference/contextualTyping12.errors.txt
+++ b/tests/baselines/reference/contextualTyping12.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTyping12.ts(1,13): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+tests/cases/compiler/contextualTyping12.ts(1,57): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
       Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
@@ -6,7 +6,7 @@ tests/cases/compiler/contextualTyping12.ts(1,13): error TS2322: Type '({ id: num
 
 ==== tests/cases/compiler/contextualTyping12.ts (1 errors) ====
     class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
-                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                                                            ~~~~~~~~~~
 !!! error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
 !!! error TS2322:   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
diff --git a/tests/baselines/reference/contextualTyping17.errors.txt b/tests/baselines/reference/contextualTyping17.errors.txt
index 24c428db58b..b6375c9c9c9 100644
--- a/tests/baselines/reference/contextualTyping17.errors.txt
+++ b/tests/baselines/reference/contextualTyping17.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/compiler/contextualTyping17.ts(1,33): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+tests/cases/compiler/contextualTyping17.ts(1,47): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
 
 
 ==== tests/cases/compiler/contextualTyping17.ts (1 errors) ====
     var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
-                                    ~~~
+                                                  ~~~~~~~~~~
 !!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping2.errors.txt b/tests/baselines/reference/contextualTyping2.errors.txt
index 2665204b167..1daa4a2a71f 100644
--- a/tests/baselines/reference/contextualTyping2.errors.txt
+++ b/tests/baselines/reference/contextualTyping2.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/compiler/contextualTyping2.ts(1,5): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+tests/cases/compiler/contextualTyping2.ts(1,32): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
 
 
 ==== tests/cases/compiler/contextualTyping2.ts (1 errors) ====
     var foo: {id:number;} = {id:4, name:"foo"};
-        ~~~
+                                   ~~~~~~~~~~
 !!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping20.errors.txt b/tests/baselines/reference/contextualTyping20.errors.txt
index d723dcd1d1b..a9112f1db84 100644
--- a/tests/baselines/reference/contextualTyping20.errors.txt
+++ b/tests/baselines/reference/contextualTyping20.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTyping20.ts(1,36): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+tests/cases/compiler/contextualTyping20.ts(1,58): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
       Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
@@ -6,7 +6,7 @@ tests/cases/compiler/contextualTyping20.ts(1,36): error TS2322: Type '({ id: num
 
 ==== tests/cases/compiler/contextualTyping20.ts (1 errors) ====
     var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
-                                       ~~~
+                                                             ~~~~~~~~~~
 !!! error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
 !!! error TS2322:   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
diff --git a/tests/baselines/reference/contextualTyping4.errors.txt b/tests/baselines/reference/contextualTyping4.errors.txt
index 48eb2c406f0..c472e7ccb18 100644
--- a/tests/baselines/reference/contextualTyping4.errors.txt
+++ b/tests/baselines/reference/contextualTyping4.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/compiler/contextualTyping4.ts(1,13): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+tests/cases/compiler/contextualTyping4.ts(1,46): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
 
 
 ==== tests/cases/compiler/contextualTyping4.ts (1 errors) ====
     class foo { public bar:{id:number;} = {id:5, name:"foo"}; }
-                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                                                 ~~~~~~~~~~
 !!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping9.errors.txt b/tests/baselines/reference/contextualTyping9.errors.txt
index f959d1e2e69..4a12574fa21 100644
--- a/tests/baselines/reference/contextualTyping9.errors.txt
+++ b/tests/baselines/reference/contextualTyping9.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTyping9.ts(1,5): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+tests/cases/compiler/contextualTyping9.ts(1,42): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
       Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
@@ -6,7 +6,7 @@ tests/cases/compiler/contextualTyping9.ts(1,5): error TS2322: Type '({ id: numbe
 
 ==== tests/cases/compiler/contextualTyping9.ts (1 errors) ====
     var foo:{id:number;}[] = [{id:1}, {id:2, name:"foo"}];
-        ~~~
+                                             ~~~~~~~~~~
 !!! error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
 !!! error TS2322:   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
 !!! error TS2322:     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
diff --git a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.errors.txt b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.errors.txt
index dc2db292eb5..19bf8d1ff22 100644
--- a/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.errors.txt
+++ b/tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/memberFunctionDeclarations/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts(14,28): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; }'.
+tests/cases/conformance/classes/propertyMemberDeclarations/memberFunctionDeclarations/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.ts(14,36): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; }'.
   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
 
 
@@ -17,7 +17,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/memberFunctionDeclara
         bar() {
             var r = super.foo({ a: 1 }); // { a: number }
             var r2 = super.foo({ a: 1, b: 2 }); // { a: number }
-                               ~~~~~~~~~~~~~~
+                                       ~~~~
 !!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; }'.
 !!! error TS2345:   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
             var r3 = this.foo({ a: 1, b: 2 }); // { a: number; b: number; }
diff --git a/tests/baselines/reference/destructuringParameterProperties5.errors.txt b/tests/baselines/reference/destructuringParameterProperties5.errors.txt
index 47e50b1df83..cfb38fde90b 100644
--- a/tests/baselines/reference/destructuringParameterProperties5.errors.txt
+++ b/tests/baselines/reference/destructuringParameterProperties5.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,51): error TS2339: Property 'x3' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,62): error TS2339: Property 'y' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,72): error TS2339: Property 'z' does not exist on type 'C1'.
-tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(11,16): error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
+tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(11,19): error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
   Types of property '0' are incompatible.
     Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
       Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
@@ -43,7 +43,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(1
     }
     
     var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]);
-                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                      ~~~~~~
 !!! error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
 !!! error TS2345:   Types of property '0' are incompatible.
 !!! error TS2345:     Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
diff --git a/tests/baselines/reference/incompatibleTypes.errors.txt b/tests/baselines/reference/incompatibleTypes.errors.txt
index e8763b0d54c..e612600a7f8 100644
--- a/tests/baselines/reference/incompatibleTypes.errors.txt
+++ b/tests/baselines/reference/incompatibleTypes.errors.txt
@@ -18,9 +18,9 @@ tests/cases/compiler/incompatibleTypes.ts(42,5): error TS2345: Argument of type
   Types of property 'p1' are incompatible.
     Type '() => string' is not assignable to type '(s: string) => number'.
       Type 'string' is not assignable to type 'number'.
-tests/cases/compiler/incompatibleTypes.ts(49,5): error TS2345: Argument of type '{ e: number; f: number; }' is not assignable to parameter of type '{ c: { b: string; }; d: string; }'.
+tests/cases/compiler/incompatibleTypes.ts(49,7): error TS2345: Argument of type '{ e: number; f: number; }' is not assignable to parameter of type '{ c: { b: string; }; d: string; }'.
   Object literal may only specify known properties, and 'e' does not exist in type '{ c: { b: string; }; d: string; }'.
-tests/cases/compiler/incompatibleTypes.ts(66,5): error TS2322: Type '{ e: number; f: number; }' is not assignable to type '{ a: { a: string; }; b: string; }'.
+tests/cases/compiler/incompatibleTypes.ts(66,47): error TS2322: Type '{ e: number; f: number; }' is not assignable to type '{ a: { a: string; }; b: string; }'.
   Object literal may only specify known properties, and 'e' does not exist in type '{ a: { a: string; }; b: string; }'.
 tests/cases/compiler/incompatibleTypes.ts(72,5): error TS2322: Type 'number' is not assignable to type '() => string'.
 tests/cases/compiler/incompatibleTypes.ts(74,5): error TS2322: Type '(a: any) => number' is not assignable to type '() => any'.
@@ -101,7 +101,7 @@ tests/cases/compiler/incompatibleTypes.ts(74,5): error TS2322: Type '(a: any) =>
     function of1(a: any) { return null; }
     
     of1({ e: 0, f: 0 });
-        ~~~~~~~~~~~~~~
+          ~~~~
 !!! error TS2345: Argument of type '{ e: number; f: number; }' is not assignable to parameter of type '{ c: { b: string; }; d: string; }'.
 !!! error TS2345:   Object literal may only specify known properties, and 'e' does not exist in type '{ c: { b: string; }; d: string; }'.
     
@@ -121,7 +121,7 @@ tests/cases/compiler/incompatibleTypes.ts(74,5): error TS2322: Type '(a: any) =>
     }
     
     var o1: { a: { a: string; }; b: string; } = { e: 0, f: 0 };
-        ~~
+                                                  ~~~~
 !!! error TS2322: Type '{ e: number; f: number; }' is not assignable to type '{ a: { a: string; }; b: string; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'e' does not exist in type '{ a: { a: string; }; b: string; }'.
     
diff --git a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.errors.txt b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.errors.txt
index bd210c55570..484c8f63b46 100644
--- a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.errors.txt
+++ b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/expressions/binaryOperators/logicalOrOperator/logicalOrExpressionIsContextuallyTyped.ts(6,5): error TS2322: Type '{ a: string; b: number; } | { a: string; b: boolean; }' is not assignable to type '{ a: string; }'.
+tests/cases/conformance/expressions/binaryOperators/logicalOrOperator/logicalOrExpressionIsContextuallyTyped.ts(6,33): error TS2322: Type '{ a: string; b: number; } | { a: string; b: boolean; }' is not assignable to type '{ a: string; }'.
   Type '{ a: string; b: number; }' is not assignable to type '{ a: string; }'.
     Object literal may only specify known properties, and 'b' does not exist in type '{ a: string; }'.
 
@@ -10,7 +10,7 @@ tests/cases/conformance/expressions/binaryOperators/logicalOrOperator/logicalOrE
     // operand types.
     
     var r: { a: string } = { a: '', b: 123 } || { a: '', b: true };
-        ~
+                                    ~~~~~~
 !!! error TS2322: Type '{ a: string; b: number; } | { a: string; b: boolean; }' is not assignable to type '{ a: string; }'.
 !!! error TS2322:   Type '{ a: string; b: number; }' is not assignable to type '{ a: string; }'.
 !!! error TS2322:     Object literal may only specify known properties, and 'b' does not exist in type '{ a: string; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLitStructuralTypeMismatch.errors.txt b/tests/baselines/reference/objectLitStructuralTypeMismatch.errors.txt
index 465c4d6d9f6..1b79e4db5ad 100644
--- a/tests/baselines/reference/objectLitStructuralTypeMismatch.errors.txt
+++ b/tests/baselines/reference/objectLitStructuralTypeMismatch.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/objectLitStructuralTypeMismatch.ts(2,5): error TS2322: Type '{ b: number; }' is not assignable to type '{ a: number; }'.
+tests/cases/compiler/objectLitStructuralTypeMismatch.ts(2,27): error TS2322: Type '{ b: number; }' is not assignable to type '{ a: number; }'.
   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
 
 
 ==== tests/cases/compiler/objectLitStructuralTypeMismatch.ts (1 errors) ====
     // Shouldn't compile
     var x: { a: number; } = { b: 5 };
-        ~
+                              ~~~~
 !!! error TS2322: Type '{ b: number; }' is not assignable to type '{ a: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLiteralFunctionArgContextualTyping.errors.txt b/tests/baselines/reference/objectLiteralFunctionArgContextualTyping.errors.txt
index 149aca43a42..fb2cbdaf649 100644
--- a/tests/baselines/reference/objectLiteralFunctionArgContextualTyping.errors.txt
+++ b/tests/baselines/reference/objectLiteralFunctionArgContextualTyping.errors.txt
@@ -1,6 +1,6 @@
-tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(8,4): error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I'.
+tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(8,6): error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I'.
   Object literal may only specify known properties, and 'hello' does not exist in type 'I'.
-tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(10,4): error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I'.
+tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(10,17): error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I'.
   Object literal may only specify known properties, and 'what' does not exist in type 'I'.
 tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(11,4): error TS2345: Argument of type '{ toString: (s: string) => string; }' is not assignable to parameter of type 'I'.
   Property 'value' is missing in type '{ toString: (s: string) => string; }'.
@@ -18,12 +18,12 @@ tests/cases/compiler/objectLiteralFunctionArgContextualTyping.ts(13,36): error T
     function f2(args: I) { }
     
     f2({ hello: 1 }) // error 
-       ~~~~~~~~~~~~
+         ~~~~~~~~
 !!! error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I'.
 !!! error TS2345:   Object literal may only specify known properties, and 'hello' does not exist in type 'I'.
     f2({ value: '' }) // missing toString satisfied by Object's member
     f2({ value: '', what: 1 }) // missing toString satisfied by Object's member
-       ~~~~~~~~~~~~~~~~~~~~~~
+                    ~~~~~~~
 !!! error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I'.
 !!! error TS2345:   Object literal may only specify known properties, and 'what' does not exist in type 'I'.
     f2({ toString: (s) => s }) // error, missing property value from ArgsString
diff --git a/tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.errors.txt b/tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.errors.txt
index 367a676abc6..b967b227809 100644
--- a/tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.errors.txt
+++ b/tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(8,4): error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I2'.
+tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(8,6): error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I2'.
   Object literal may only specify known properties, and 'hello' does not exist in type 'I2'.
 tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(9,4): error TS2345: Argument of type '{ value: string; }' is not assignable to parameter of type 'I2'.
   Property 'doStuff' is missing in type '{ value: string; }'.
-tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(10,4): error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I2'.
+tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(10,17): error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I2'.
   Object literal may only specify known properties, and 'what' does not exist in type 'I2'.
 tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(11,4): error TS2345: Argument of type '{ toString: (s: any) => any; }' is not assignable to parameter of type 'I2'.
   Property 'value' is missing in type '{ toString: (s: any) => any; }'.
@@ -21,7 +21,7 @@ tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(13,4): error T
     function f2(args: I2) { }
     
     f2({ hello: 1 }) 
-       ~~~~~~~~~~~~
+         ~~~~~~~~
 !!! error TS2345: Argument of type '{ hello: number; }' is not assignable to parameter of type 'I2'.
 !!! error TS2345:   Object literal may only specify known properties, and 'hello' does not exist in type 'I2'.
     f2({ value: '' })
@@ -29,7 +29,7 @@ tests/cases/compiler/objectLiteralFunctionArgContextualTyping2.ts(13,4): error T
 !!! error TS2345: Argument of type '{ value: string; }' is not assignable to parameter of type 'I2'.
 !!! error TS2345:   Property 'doStuff' is missing in type '{ value: string; }'.
     f2({ value: '', what: 1 }) 
-       ~~~~~~~~~~~~~~~~~~~~~~
+                    ~~~~~~~
 !!! error TS2345: Argument of type '{ value: string; what: number; }' is not assignable to parameter of type 'I2'.
 !!! error TS2345:   Object literal may only specify known properties, and 'what' does not exist in type 'I2'.
     f2({ toString: (s) => s }) 
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.errors.txt b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.errors.txt
index d00a8ddf074..50839d5e56b 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.errors.txt
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts(4,5): error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
+tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts(4,43): error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
   Object literal may only specify known properties, and 'name' does not exist in type '{ b: string; id: number; }'.
 tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts(5,16): error TS1131: Property or signature expected.
 tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentError.ts(5,22): error TS2403: Subsequent variable declarations must have the same type.  Variable 'id' must be of type 'number', but here has type 'any'.
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPr
     var name: string = "my name";
     
     var person: { b: string; id: number } = { name, id };  // error
-        ~~~~~~
+                                              ~~~~
 !!! error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ b: string; id: number; }'.
     var person1: { name, id };  // error: can't use short-hand property assignment in type position
diff --git a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.errors.txt b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.errors.txt
index f6f4f625c45..b4f695c835d 100644
--- a/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.errors.txt
+++ b/tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts(4,5): error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
+tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts(4,43): error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
   Object literal may only specify known properties, and 'name' does not exist in type '{ b: string; id: number; }'.
 tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.ts(5,79): error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ name: number; id: string; }'.
   Types of property 'name' are incompatible.
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/shorthandPropertyAssignment/objectLiteralShorthandPr
     var name: string = "my name";
     
     var person: { b: string; id: number } = { name, id };  // error
-        ~~~~~~
+                                              ~~~~
 !!! error TS2322: Type '{ name: string; id: number; }' is not assignable to type '{ b: string; id: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ b: string; id: number; }'.
     function bar(name: string, id: number): { name: number, id: string } { return { name, id }; }  // error
diff --git a/tests/baselines/reference/orderMattersForSignatureGroupIdentity.errors.txt b/tests/baselines/reference/orderMattersForSignatureGroupIdentity.errors.txt
index 47401a7ae8b..f108f0ea92d 100644
--- a/tests/baselines/reference/orderMattersForSignatureGroupIdentity.errors.txt
+++ b/tests/baselines/reference/orderMattersForSignatureGroupIdentity.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(19,3): error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
+tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(19,5): error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
   Object literal may only specify known properties, and 's' does not exist in type '{ n: number; }'.
 tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(22,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'w' must be of type 'A', but here has type 'C'.
-tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(24,3): error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
+tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(24,5): error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
   Object literal may only specify known properties, and 's' does not exist in type '{ n: number; }'.
 
 
@@ -25,7 +25,7 @@ tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(24,3): error TS234
     var v: B;
     
     v({ s: "", n: 0 }).toLowerCase();
-      ~~~~~~~~~~~~~~~
+        ~~~~~
 !!! error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
 !!! error TS2345:   Object literal may only specify known properties, and 's' does not exist in type '{ n: number; }'.
     
@@ -35,6 +35,6 @@ tests/cases/compiler/orderMattersForSignatureGroupIdentity.ts(24,3): error TS234
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'w' must be of type 'A', but here has type 'C'.
     
     w({ s: "", n: 0 }).toLowerCase();
-      ~~~~~~~~~~~~~~~
+        ~~~~~
 !!! error TS2345: Argument of type '{ s: string; n: number; }' is not assignable to parameter of type '{ n: number; }'.
 !!! error TS2345:   Object literal may only specify known properties, and 's' does not exist in type '{ n: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/switchStatements.errors.txt b/tests/baselines/reference/switchStatements.errors.txt
index aa5b796e252..c99b0eba909 100644
--- a/tests/baselines/reference/switchStatements.errors.txt
+++ b/tests/baselines/reference/switchStatements.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/statements/switchStatements/switchStatements.ts(35,10): error TS2322: Type '{ id: number; name: string; }' is not assignable to type 'C'.
+tests/cases/conformance/statements/switchStatements/switchStatements.ts(35,20): error TS2322: Type '{ id: number; name: string; }' is not assignable to type 'C'.
   Object literal may only specify known properties, and 'name' does not exist in type 'C'.
 
 
@@ -38,7 +38,7 @@ tests/cases/conformance/statements/switchStatements/switchStatements.ts(35,10):
     switch (new C()) {
         case new D():
         case { id: 12, name: '' }:
-             ~~~~~~~~~~~~~~~~~~~~
+                       ~~~~~~~~
 !!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type 'C'.
 !!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type 'C'.
         case new C():
diff --git a/tests/baselines/reference/symbolProperty21.errors.txt b/tests/baselines/reference/symbolProperty21.errors.txt
index b9162acc84f..fa9cabc9b61 100644
--- a/tests/baselines/reference/symbolProperty21.errors.txt
+++ b/tests/baselines/reference/symbolProperty21.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/Symbols/symbolProperty21.ts(8,5): error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }' is not assignable to parameter of type 'I<boolean, string>'.
+tests/cases/conformance/es6/Symbols/symbolProperty21.ts(10,5): error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }' is not assignable to parameter of type 'I<boolean, string>'.
   Object literal may only specify known properties, and '[Symbol.toPrimitive]' does not exist in type 'I<boolean, string>'.
 
 
@@ -11,14 +11,10 @@ tests/cases/conformance/es6/Symbols/symbolProperty21.ts(8,5): error TS2345: Argu
     declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
     
     foo({
-        ~
         [Symbol.isConcatSpreadable]: "",
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         [Symbol.toPrimitive]: 0,
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        [Symbol.unscopables]: true
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    });
-    ~
+        ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }' is not assignable to parameter of type 'I<boolean, string>'.
-!!! error TS2345:   Object literal may only specify known properties, and '[Symbol.toPrimitive]' does not exist in type 'I<boolean, string>'.
\ No newline at end of file
+!!! error TS2345:   Object literal may only specify known properties, and '[Symbol.toPrimitive]' does not exist in type 'I<boolean, string>'.
+        [Symbol.unscopables]: true
+    });
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
index 6464366d33d..be5c21f1a0b 100644
--- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(64,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
-tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
 
@@ -86,7 +86,7 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference
     }
     
     var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
-              ~~~~~~~~~~~~~
+                                                                                  ~~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
index be8c517d39c..63d04a42b3b 100644
--- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(63,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
-tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(76,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(76,79): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
 
@@ -85,7 +85,7 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference
     }
     
     var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
-              ~~~~~~~~~~~~~
+                                                                                  ~~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
diff --git a/tests/baselines/reference/typeArgInference2.errors.txt b/tests/baselines/reference/typeArgInference2.errors.txt
index 71d2a13f4a1..b7201fd1033 100644
--- a/tests/baselines/reference/typeArgInference2.errors.txt
+++ b/tests/baselines/reference/typeArgInference2.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/typeArgInference2.ts(12,10): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/compiler/typeArgInference2.ts(12,52): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ name: string; a: number; }' is not a valid type argument because it is not a supertype of candidate '{ name: string; b: number; }'.
     Object literal may only specify known properties, and 'b' does not exist in type '{ name: string; a: number; }'.
 
@@ -16,7 +16,7 @@ tests/cases/compiler/typeArgInference2.ts(12,10): error TS2453: The type argumen
     var z4 = foo({ name: "abc" });        // { name: string }
     var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
     var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // error
-             ~~~
+                                                       ~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ name: string; a: number; }' is not a valid type argument because it is not a supertype of candidate '{ name: string; b: number; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'b' does not exist in type '{ name: string; a: number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgumentInference.errors.txt b/tests/baselines/reference/typeArgumentInference.errors.txt
index 669ebadd28a..51cf4ccf7d2 100644
--- a/tests/baselines/reference/typeArgumentInference.errors.txt
+++ b/tests/baselines/reference/typeArgumentInference.errors.txt
@@ -1,9 +1,9 @@
 tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(68,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(82,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(82,69): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(84,66): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(84,74): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
 
 
@@ -93,13 +93,13 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(84,66
         z?: Date;
     }
     var a9e = someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
-              ~~~~~~~~~~~~~
+                                                                        ~~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: Date; }'.
     var a9e: {};
     var a9f = someGenerics9<A92>(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
-                                                                     ~~~~~~~~~~~~~~~
+                                                                             ~~~~~
 !!! error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
 !!! error TS2345:   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
     var a9f: A92;
diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
index 305eee1c941..d058426b9c9 100644
--- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
@@ -12,12 +12,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(106,15): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(118,9): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,15): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,51): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,69): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ x: number; z: any; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: any; }'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,51): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,56): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,66): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,74): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
 
 
@@ -163,17 +163,17 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
 !!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
-                  ~~~~~~~~~~~~~
+                                                      ~~~~~~
+!!! error TS2304: Cannot find name 'window'.
+                                                                        ~~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ x: number; z: any; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: any; }'.
-                                                      ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     var a9e: {};
     var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
                                                            ~~~~~~
 !!! error TS2304: Cannot find name 'window'.
-                                                                     ~~~~~~~~~~~~~~~
+                                                                             ~~~~~
 !!! error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
 !!! error TS2345:   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
     var a9f: A92;
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
index 6b81cd6f232..0c1e8cc4e97 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
@@ -17,12 +17,12 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(73,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(85,9): error TS2304: Cannot find name 'Window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,47): error TS2304: Cannot find name 'window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,65): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate '{ x: number; z: any; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: any; }'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,47): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,52): error TS2304: Cannot find name 'window'.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,62): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,70): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
 
 
@@ -145,17 +145,17 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
 !!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
-              ~~~~~~~~~~~~~
+                                                  ~~~~~~
+!!! error TS2304: Cannot find name 'window'.
+                                                                    ~~~~~
 !!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate '{ x: number; z: any; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
 !!! error TS2453:     Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; z: any; }'.
-                                                  ~~~~~~
-!!! error TS2304: Cannot find name 'window'.
     var a9e: {};
     var a9f = someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
                                                        ~~~~~~
 !!! error TS2304: Cannot find name 'window'.
-                                                                 ~~~~~~~~~~~~~~~
+                                                                         ~~~~~
 !!! error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type 'A92'.
 !!! error TS2345:   Object literal may only specify known properties, and 'y' does not exist in type 'A92'.
     var a9f: A92;
diff --git a/tests/baselines/reference/typeInfer1.errors.txt b/tests/baselines/reference/typeInfer1.errors.txt
index 2550bb1fe8d..6f26b2e6054 100644
--- a/tests/baselines/reference/typeInfer1.errors.txt
+++ b/tests/baselines/reference/typeInfer1.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/typeInfer1.ts(11,5): error TS2322: Type '{ Moo: () => string; }' is not assignable to type 'ITextWriter2'.
+tests/cases/compiler/typeInfer1.ts(12,5): error TS2322: Type '{ Moo: () => string; }' is not assignable to type 'ITextWriter2'.
   Object literal may only specify known properties, and 'Moo' does not exist in type 'ITextWriter2'.
 
 
@@ -14,8 +14,8 @@ tests/cases/compiler/typeInfer1.ts(11,5): error TS2322: Type '{ Moo: () => strin
     }
     
     var yyyyyyyy: ITextWriter2 = {
-        ~~~~~~~~
+        Moo: function() { return "cow"; }
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2322: Type '{ Moo: () => string; }' is not assignable to type 'ITextWriter2'.
 !!! error TS2322:   Object literal may only specify known properties, and 'Moo' does not exist in type 'ITextWriter2'.
-        Moo: function() { return "cow"; }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/typeMatch2.errors.txt b/tests/baselines/reference/typeMatch2.errors.txt
index a497551c953..e82439c0ad5 100644
--- a/tests/baselines/reference/typeMatch2.errors.txt
+++ b/tests/baselines/reference/typeMatch2.errors.txt
@@ -2,9 +2,9 @@ tests/cases/compiler/typeMatch2.ts(3,2): error TS2322: Type '{}' is not assignab
   Property 'x' is missing in type '{}'.
 tests/cases/compiler/typeMatch2.ts(4,5): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: number; y: number; }'.
   Property 'y' is missing in type '{ x: number; }'.
-tests/cases/compiler/typeMatch2.ts(5,2): error TS2322: Type '{ x: number; y: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
+tests/cases/compiler/typeMatch2.ts(5,20): error TS2322: Type '{ x: number; y: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
-tests/cases/compiler/typeMatch2.ts(6,5): error TS2322: Type '{ x: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
+tests/cases/compiler/typeMatch2.ts(6,17): error TS2322: Type '{ x: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
 tests/cases/compiler/typeMatch2.ts(18,5): error TS2322: Type 'Animal[]' is not assignable to type 'Giraffe[]'.
   Type 'Animal' is not assignable to type 'Giraffe'.
@@ -13,7 +13,7 @@ tests/cases/compiler/typeMatch2.ts(22,5): error TS2322: Type '{ f1: number; f2:
   Types of property 'f2' are incompatible.
     Type 'Animal[]' is not assignable to type 'Giraffe[]'.
       Type 'Animal' is not assignable to type 'Giraffe'.
-tests/cases/compiler/typeMatch2.ts(34,5): error TS2322: Type '{ x: number; y: any; z: number; }' is not assignable to type '{ x: number; y: number; }'.
+tests/cases/compiler/typeMatch2.ts(34,26): error TS2322: Type '{ x: number; y: any; z: number; }' is not assignable to type '{ x: number; y: number; }'.
   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
 tests/cases/compiler/typeMatch2.ts(35,5): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: number; y: number; }'.
   Property 'y' is missing in type '{ x: number; }'.
@@ -31,11 +31,11 @@ tests/cases/compiler/typeMatch2.ts(35,5): error TS2322: Type '{ x: number; }' is
 !!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: number; y: number; }'.
 !!! error TS2322:   Property 'y' is missing in type '{ x: number; }'.
     	a = { x: 1, y: 2, z: 3 };
-    	~
+    	                  ~~~~
 !!! error TS2322: Type '{ x: number; y: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
         a = { x: 1, z: 3 };  // error
-        ~
+                    ~~~~
 !!! error TS2322: Type '{ x: number; z: number; }' is not assignable to type '{ x: number; y: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
     }
@@ -75,7 +75,7 @@ tests/cases/compiler/typeMatch2.ts(35,5): error TS2322: Type '{ x: number; }' is
         a = { x: 1, y: undefined }; 
         a = { x: 1, y: _any }; 
         a = { x: 1, y: _any, z:1 }; 
-        ~
+                             ~~~
 !!! error TS2322: Type '{ x: number; y: any; z: number; }' is not assignable to type '{ x: number; y: number; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'z' does not exist in type '{ x: number; y: number; }'.
         a = { x: 1 }; // error

From 5ff945bc5efc82a82a1e4aea7482b50dad1e5832 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Mon, 31 Aug 2015 01:09:48 -0700
Subject: [PATCH 14/17] Style.

---
 src/compiler/checker.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index cb53531f6b3..91d7a1ebca9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4777,8 +4777,11 @@ namespace ts {
                 for (let prop of getPropertiesOfObjectType(source)) {
                     if (!isKnownProperty(target, prop.name)) {
                         if (reportErrors) {
-                            reportErrorAndTryImproveErrorNode(prop.valueDeclaration,
-                                Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target));
+                            reportErrorAndTryImproveErrorNode(
+                                prop.valueDeclaration,
+                                Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
+                                symbolToString(prop),
+                                typeToString(target));
                         }
                         return true;
                     }

From ad3cca3d4f243980b3aa945d37b70cc643c5b361 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Mon, 31 Aug 2015 14:53:02 -0700
Subject: [PATCH 15/17] Added comment, inlined function.

---
 src/compiler/checker.ts | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 91d7a1ebca9..f71009c7b65 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4548,7 +4548,7 @@ namespace ts {
          * @param target The right-hand-side of the relation.
          * @param relation The relation considered. One of 'identityRelation', 'assignableRelation', or 'subTypeRelation'.
          * Used as both to determine which checks are performed and as a cache of previously computed results.
-         * @param errorNode The node upon which all errors will be reported, if defined.
+         * @param errorNode The suggested node upon which all errors will be reported, if defined. This may or may not be the actual node used.
          * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used.
          * @param containingMessageChain A chain of errors to prepend any new errors found.
          */
@@ -4593,16 +4593,6 @@ namespace ts {
             }
             return result !== Ternary.False;
 
-            function reportErrorAndTryImproveErrorNode(
-                    newErrorNode: Node,
-                    message: DiagnosticMessage,
-                    arg0?: string,
-                    arg1?: string,
-                    arg2?: string) {
-                errorNode = newErrorNode || errorNode;
-                reportError(message, arg0, arg1, arg2);
-            }
-
             function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void {
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
             }
@@ -4777,11 +4767,13 @@ namespace ts {
                 for (let prop of getPropertiesOfObjectType(source)) {
                     if (!isKnownProperty(target, prop.name)) {
                         if (reportErrors) {
-                            reportErrorAndTryImproveErrorNode(
-                                prop.valueDeclaration,
-                                Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
-                                symbolToString(prop),
-                                typeToString(target));
+                            // We know *exactly* where things went wrong when comparing the types.
+                            // Use this property as the error node as this will be more helpful in
+                            // reasoning about what went wrong.
+                            errorNode = prop.valueDeclaration
+                            reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
+                                        symbolToString(prop),
+                                        typeToString(target));
                         }
                         return true;
                     }

From 3e2be80d8ae7c92882a581691cf40ac5f1984d08 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Tue, 1 Sep 2015 11:09:41 -0700
Subject: [PATCH 16/17] remove 'experimental' from 'moduleResolution' command
 line argument

---
 src/compiler/commandLineParser.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 1a0c971001e..c56a18b3ab2 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -243,7 +243,6 @@ namespace ts {
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic
             },
-            experimental: true,
             description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_or_classic_TypeScript_pre_1_6
         }        
     ];

From 03da2ce42b3c77375043ff7c96fe14357e9a099f Mon Sep 17 00:00:00 2001
From: Graeme Wicksted <graeme.wicksted@gmail.com>
Date: Wed, 2 Sep 2015 10:19:49 -0400
Subject: [PATCH 17/17] Added toLocaleTimeString variations

See [Mozilla Reference ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString)
---
 src/lib/intl.d.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/lib/intl.d.ts b/src/lib/intl.d.ts
index 1265dc51486..b5291306b87 100644
--- a/src/lib/intl.d.ts
+++ b/src/lib/intl.d.ts
@@ -170,17 +170,32 @@ interface Date {
       */
     toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date and time to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }