From fc5b2e524de5e6118970ab8b0f7eb4e1dfb2445f Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sun, 16 Oct 2016 18:34:57 +0200
Subject: [PATCH 001/159] Fix for issue #442

---
 .../staticPropertyNameConflictsEs5.ts         | 26 +++++++++++++++++++
 .../staticPropertyNameConflictsEs6.ts         | 25 ++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
 create mode 100644 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts

diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
new file mode 100644
index 00000000000..0f260673d9d
--- /dev/null
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
@@ -0,0 +1,26 @@
+// @target: es5   
+
+// static name
+class A {
+    static name: number; // error
+    name: string; // ok
+}
+
+class B {
+    static name() {} // error
+    name() {} // ok
+}
+
+
+
+// static length...
+class C {
+    static length: number; // error
+    length: string; // ok
+}
+
+class D {
+    static length() {} // error
+    length() {} // ok
+}
+
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
new file mode 100644
index 00000000000..47c7dbbde25
--- /dev/null
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
@@ -0,0 +1,25 @@
+// @target: es6
+
+
+// static name
+class A {
+    static name: string; // ok
+    name: string; // ok
+}
+
+class B {
+    static name() {}; // ok
+    name() {}; // ok
+}
+
+
+// static length
+class C {
+    static length: number; // ok
+    length: string; // ok
+}
+
+class D {
+    static length() {} // ok
+    length() {} // ok
+}

From 8a37a162b2d15fd04d3f8961269e66951bda1343 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sun, 16 Oct 2016 18:43:55 +0200
Subject: [PATCH 002/159] Fix for issue #442

---
 src/compiler/checker.ts                       |  45 +++++++
 src/compiler/diagnosticMessages.json          |   5 +-
 .../propertyNamedPrototype.errors.txt         |  10 ++
 ...cMemberOfAnotherClassAssignment.errors.txt |  30 ++---
 ...AndPublicMemberOfAnotherClassAssignment.js |  26 ++--
 .../staticPropertyNameConflictsEs5.errors.txt |  92 ++++++++++++++
 .../staticPropertyNameConflictsEs5.js         | 120 ++++++++++++++++++
 .../staticPropertyNameConflictsEs6.errors.txt |  80 ++++++++++++
 .../staticPropertyNameConflictsEs6.js         |  89 +++++++++++++
 .../staticPrototypeProperty.errors.txt        |   8 +-
 ...AndPublicMemberOfAnotherClassAssignment.ts |  14 +-
 .../staticPropertyNameConflictsEs5.ts         |  42 +++++-
 .../staticPropertyNameConflictsEs6.ts         |  49 +++++--
 13 files changed, 558 insertions(+), 52 deletions(-)
 create mode 100644 tests/baselines/reference/propertyNamedPrototype.errors.txt
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs5.js
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs6.js

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8568cd5feed..f4f3a77e9be 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -13922,6 +13922,50 @@ namespace ts {
             }
         }
 
+        // Static members may conflict with non-configurable non-writable built-in Function.prototype properties 
+        // see https://github.com/microsoft/typescript/issues/442.
+        function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) { 
+            const es5_descriptors: PropertyDescriptorMap = {
+                // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
+                // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
+                "name":      {configurable: false, writable: false},
+                "length":    {configurable: false, writable: false},
+                "prototype": {configurable: false, writable: false},
+
+                // see https://github.com/microsoft/typescript/issues/442
+                "caller":    {configurable: false, writable: false},
+                "arguments": {configurable: false, writable: false}
+            }; 
+            const post_es5_descriptors: PropertyDescriptorMap = {
+                // see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
+                // see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
+                "name":      {configurable: true,  writable: false},
+                "length":    {configurable: true,  writable: false},
+                "prototype": {configurable: false, writable: false},
+                "caller":    {configurable: false, writable: false},
+                "arguments": {configurable: false, writable: false}
+            };
+            const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
+            const className = getSymbolOfNode(node).name;
+            
+            for (let member of node.members) {
+                let isStatic = forEach(member.modifiers, (m:Modifier) => m.kind === SyntaxKind.StaticKeyword);
+                if (isStatic) {
+                    let memberNameNode = member.name;
+                    let memberName = getPropertyNameForPropertyNameNode(memberNameNode);
+                    let descriptor: PropertyDescriptor = null;
+                    if (languageVersion <= ScriptTarget.ES5) {
+                        descriptor = es5_descriptors.hasOwnProperty(memberName) ? es5_descriptors[memberName] : null;
+                    } else if (languageVersion > ScriptTarget.ES5) {
+                        descriptor = post_es5_descriptors.hasOwnProperty(memberName) ? post_es5_descriptors[memberName] : null;                           
+                    }
+                    if (descriptor && descriptor.configurable === false && descriptor.writable === false) { 
+                        error(memberNameNode, message, memberName, className);
+                    }
+                }
+            }
+        }
+
         function checkObjectTypeForDuplicateDeclarations(node: TypeLiteralNode | InterfaceDeclaration) {
             const names = createMap<boolean>();
             for (const member of node.members) {
@@ -16423,6 +16467,7 @@ namespace ts {
             const staticType = <ObjectType>getTypeOfSymbol(symbol);
             checkTypeParameterListsIdentical(node, symbol);
             checkClassForDuplicateDeclarations(node);
+            checkClassForStaticPropertyNameConflicts(node);
 
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 6210a20afa6..6b0a6d6dfb7 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1955,6 +1955,10 @@
         "category": "Error",
         "code": 2691
     },
+    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
+        "category": "Error",
+        "code": 2692
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2239,7 +2243,6 @@
         "category": "Message",
         "code": 4090
     },
-
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
diff --git a/tests/baselines/reference/propertyNamedPrototype.errors.txt b/tests/baselines/reference/propertyNamedPrototype.errors.txt
new file mode 100644
index 00000000000..6ddd8390720
--- /dev/null
+++ b/tests/baselines/reference/propertyNamedPrototype.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts(3,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+
+
+==== tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts (1 errors) ====
+    class C {
+        prototype: number; // ok
+        static prototype: C; // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.errors.txt b/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.errors.txt
index 59626540806..36ead708331 100644
--- a/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.errors.txt
+++ b/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.errors.txt
@@ -1,43 +1,43 @@
 tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts(12,1): error TS2322: Type 'C' is not assignable to type 'A'.
-  Property 'name' is missing in type 'C'.
+  Property 'prop' is missing in type 'C'.
 tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts(13,1): error TS2322: Type 'typeof B' is not assignable to type 'A'.
-  Property 'name' is missing in type 'typeof B'.
+  Property 'prop' is missing in type 'typeof B'.
 tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts(16,5): error TS2322: Type 'C' is not assignable to type 'B'.
-  Property 'name' is missing in type 'C'.
+  Property 'prop' is missing in type 'C'.
 tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts(17,1): error TS2322: Type 'typeof B' is not assignable to type 'B'.
-  Property 'name' is missing in type 'typeof B'.
+  Property 'prop' is missing in type 'typeof B'.
 
 
 ==== tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts (4 errors) ====
     interface A {
-        name();
+        prop();
     }
     class B {
-        public name() { }
+        public prop() { }
     }
     class C {
-        public static name() { }
+        public static prop() { }
     }
     
     var a: A = new B();
-    a = new C(); // error name is missing
+    a = new C(); // error prop is missing
     ~
 !!! error TS2322: Type 'C' is not assignable to type 'A'.
-!!! error TS2322:   Property 'name' is missing in type 'C'.
-    a = B; // error name is missing
+!!! error TS2322:   Property 'prop' is missing in type 'C'.
+    a = B; // error prop is missing
     ~
 !!! error TS2322: Type 'typeof B' is not assignable to type 'A'.
-!!! error TS2322:   Property 'name' is missing in type 'typeof B'.
+!!! error TS2322:   Property 'prop' is missing in type 'typeof B'.
     a = C;
     
-    var b: B = new C(); // error name is missing
+    var b: B = new C(); // error prop is missing
         ~
 !!! error TS2322: Type 'C' is not assignable to type 'B'.
-!!! error TS2322:   Property 'name' is missing in type 'C'.
-    b = B; // error name is missing
+!!! error TS2322:   Property 'prop' is missing in type 'C'.
+    b = B; // error prop is missing
     ~
 !!! error TS2322: Type 'typeof B' is not assignable to type 'B'.
-!!! error TS2322:   Property 'name' is missing in type 'typeof B'.
+!!! error TS2322:   Property 'prop' is missing in type 'typeof B'.
     b = C;
     b = a;
     
diff --git a/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.js b/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.js
index 1b98daa226d..00de82a4f6d 100644
--- a/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.js
+++ b/tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.js
@@ -1,21 +1,21 @@
 //// [staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts]
 interface A {
-    name();
+    prop();
 }
 class B {
-    public name() { }
+    public prop() { }
 }
 class C {
-    public static name() { }
+    public static prop() { }
 }
 
 var a: A = new B();
-a = new C(); // error name is missing
-a = B; // error name is missing
+a = new C(); // error prop is missing
+a = B; // error prop is missing
 a = C;
 
-var b: B = new C(); // error name is missing
-b = B; // error name is missing
+var b: B = new C(); // error prop is missing
+b = B; // error prop is missing
 b = C;
 b = a;
 
@@ -29,21 +29,21 @@ c = a;
 var B = (function () {
     function B() {
     }
-    B.prototype.name = function () { };
+    B.prototype.prop = function () { };
     return B;
 }());
 var C = (function () {
     function C() {
     }
-    C.name = function () { };
+    C.prop = function () { };
     return C;
 }());
 var a = new B();
-a = new C(); // error name is missing
-a = B; // error name is missing
+a = new C(); // error prop is missing
+a = B; // error prop is missing
 a = C;
-var b = new C(); // error name is missing
-b = B; // error name is missing
+var b = new C(); // error prop is missing
+b = B; // error prop is missing
 b = C;
 b = a;
 var c = new B();
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
new file mode 100644
index 00000000000..182b1628522
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
@@ -0,0 +1,92 @@
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+
+
+==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts (11 errors) ====
+    
+    // static name
+    class StaticName {
+        static name: number; // error
+               ~~~~
+!!! error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+        name: string; // ok
+    }
+    
+    class StaticNameFn {
+        static name() {} // error
+               ~~~~
+!!! error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+        name() {} // ok
+    }
+    
+    
+    class StaticLength {
+        static length: number; // error
+               ~~~~~~
+!!! error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+        length: string; // ok
+    }
+    
+    class StaticLengthFn {
+        static length() {} // error
+               ~~~~~~
+!!! error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+        length() {} // ok
+    }
+    
+    
+    class StaticPrototype {
+        static prototype: number; // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+        prototype: string; // ok
+    }
+    
+    class StaticPrototypeFn {
+        static prototype() {} // error
+               ~~~~~~~~~
+!!! error TS2300: Duplicate identifier 'prototype'.
+               ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+        prototype() {} // ok
+    }
+    
+    
+    class StaticCaller {
+        static caller: number; // error
+               ~~~~~~
+!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+        caller: string; // ok
+    }
+    
+    class StaticCallerFn {
+        static caller() {} // error
+               ~~~~~~
+!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+        caller() {} // ok
+    }
+    
+    
+    class StaticArguments {
+        static arguments: number; // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+        arguments: string; // ok
+    }
+    
+    class StaticArgumentsFn {
+        static arguments() {} // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+        arguments() {} // ok
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.js b/tests/baselines/reference/staticPropertyNameConflictsEs5.js
new file mode 100644
index 00000000000..06d4a011a8e
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs5.js
@@ -0,0 +1,120 @@
+//// [staticPropertyNameConflictsEs5.ts]
+
+// static name
+class StaticName {
+    static name: number; // error
+    name: string; // ok
+}
+
+class StaticNameFn {
+    static name() {} // error
+    name() {} // ok
+}
+
+
+class StaticLength {
+    static length: number; // error
+    length: string; // ok
+}
+
+class StaticLengthFn {
+    static length() {} // error
+    length() {} // ok
+}
+
+
+class StaticPrototype {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+class StaticPrototypeFn {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+
+class StaticCaller {
+    static caller: number; // error
+    caller: string; // ok
+}
+
+class StaticCallerFn {
+    static caller() {} // error
+    caller() {} // ok
+}
+
+
+class StaticArguments {
+    static arguments: number; // error
+    arguments: string; // ok
+}
+
+class StaticArgumentsFn {
+    static arguments() {} // error
+    arguments() {} // ok
+}
+
+
+//// [staticPropertyNameConflictsEs5.js]
+// static name
+var StaticName = (function () {
+    function StaticName() {
+    }
+    return StaticName;
+}());
+var StaticNameFn = (function () {
+    function StaticNameFn() {
+    }
+    StaticNameFn.name = function () { }; // error
+    StaticNameFn.prototype.name = function () { }; // ok
+    return StaticNameFn;
+}());
+var StaticLength = (function () {
+    function StaticLength() {
+    }
+    return StaticLength;
+}());
+var StaticLengthFn = (function () {
+    function StaticLengthFn() {
+    }
+    StaticLengthFn.length = function () { }; // error
+    StaticLengthFn.prototype.length = function () { }; // ok
+    return StaticLengthFn;
+}());
+var StaticPrototype = (function () {
+    function StaticPrototype() {
+    }
+    return StaticPrototype;
+}());
+var StaticPrototypeFn = (function () {
+    function StaticPrototypeFn() {
+    }
+    StaticPrototypeFn.prototype = function () { }; // error
+    StaticPrototypeFn.prototype.prototype = function () { }; // ok
+    return StaticPrototypeFn;
+}());
+var StaticCaller = (function () {
+    function StaticCaller() {
+    }
+    return StaticCaller;
+}());
+var StaticCallerFn = (function () {
+    function StaticCallerFn() {
+    }
+    StaticCallerFn.caller = function () { }; // error
+    StaticCallerFn.prototype.caller = function () { }; // ok
+    return StaticCallerFn;
+}());
+var StaticArguments = (function () {
+    function StaticArguments() {
+    }
+    return StaticArguments;
+}());
+var StaticArgumentsFn = (function () {
+    function StaticArgumentsFn() {
+    }
+    StaticArgumentsFn.arguments = function () { }; // error
+    StaticArgumentsFn.prototype.arguments = function () { }; // ok
+    return StaticArgumentsFn;
+}());
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
new file mode 100644
index 00000000000..b76b7e02b76
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
@@ -0,0 +1,80 @@
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+
+
+==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
+    
+    
+    class StaticName {
+        static name: number; // ok
+        name: string; // ok
+    }
+    
+    class StaticNameFn {
+        static name() {} // ok
+        name() {} // ok
+    }
+    
+    
+    class StaticLength {
+        static length: number; // ok
+        length: string; // ok
+    }
+    
+    class StaticLengthFn {
+        static length() {} // ok
+        length() {} // ok
+    }
+    
+    
+    class StaticPrototype {
+        static prototype: number; // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+        prototype: string; // ok
+    }
+    
+    class StaticPrototypeFn {
+        static prototype() {} // error
+               ~~~~~~~~~
+!!! error TS2300: Duplicate identifier 'prototype'.
+               ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+        prototype() {} // ok
+    }
+    
+    
+    class StaticCaller {
+        static caller: number; // // error
+               ~~~~~~
+!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+        caller: string; // ok
+    }
+    
+    class StaticCallerFn {
+        static caller() {} // // error
+               ~~~~~~
+!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+        caller() {} // ok
+    }
+    
+    
+    class StaticArguments {
+        static arguments: number; // // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+        arguments: string; // ok
+    }
+    
+    class StaticArgumentsFn {
+        static arguments() {} // // error
+               ~~~~~~~~~
+!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+        arguments() {} // ok
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.js b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
new file mode 100644
index 00000000000..67756c37a92
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
@@ -0,0 +1,89 @@
+//// [staticPropertyNameConflictsEs6.ts]
+
+
+class StaticName {
+    static name: number; // ok
+    name: string; // ok
+}
+
+class StaticNameFn {
+    static name() {} // ok
+    name() {} // ok
+}
+
+
+class StaticLength {
+    static length: number; // ok
+    length: string; // ok
+}
+
+class StaticLengthFn {
+    static length() {} // ok
+    length() {} // ok
+}
+
+
+class StaticPrototype {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+class StaticPrototypeFn {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+
+class StaticCaller {
+    static caller: number; // // error
+    caller: string; // ok
+}
+
+class StaticCallerFn {
+    static caller() {} // // error
+    caller() {} // ok
+}
+
+
+class StaticArguments {
+    static arguments: number; // // error
+    arguments: string; // ok
+}
+
+class StaticArgumentsFn {
+    static arguments() {} // // error
+    arguments() {} // ok
+}
+
+
+//// [staticPropertyNameConflictsEs6.js]
+class StaticName {
+}
+class StaticNameFn {
+    static name() { } // ok
+    name() { } // ok
+}
+class StaticLength {
+}
+class StaticLengthFn {
+    static length() { } // ok
+    length() { } // ok
+}
+class StaticPrototype {
+}
+class StaticPrototypeFn {
+    static prototype() { } // error
+    prototype() { } // ok
+}
+class StaticCaller {
+}
+class StaticCallerFn {
+    static caller() { } // // error
+    caller() { } // ok
+}
+class StaticArguments {
+}
+class StaticArgumentsFn {
+    static arguments() { } // // error
+    arguments() { } // ok
+}
diff --git a/tests/baselines/reference/staticPrototypeProperty.errors.txt b/tests/baselines/reference/staticPrototypeProperty.errors.txt
index c3f5cb99c96..b2f36a40bed 100644
--- a/tests/baselines/reference/staticPrototypeProperty.errors.txt
+++ b/tests/baselines/reference/staticPrototypeProperty.errors.txt
@@ -1,13 +1,19 @@
 tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
 
 
-==== tests/cases/compiler/staticPrototypeProperty.ts (1 errors) ====
+==== tests/cases/compiler/staticPrototypeProperty.ts (3 errors) ====
     class C {
        static prototype() { }
               ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
+              ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
     }
      
     class C2 {
        static prototype;
+              ~~~~~~~~~
+!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
     }
\ No newline at end of file
diff --git a/tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts b/tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts
index c8ebc312104..aa78d4333c6 100644
--- a/tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts
+++ b/tests/cases/compiler/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.ts
@@ -1,20 +1,20 @@
 interface A {
-    name();
+    prop();
 }
 class B {
-    public name() { }
+    public prop() { }
 }
 class C {
-    public static name() { }
+    public static prop() { }
 }
 
 var a: A = new B();
-a = new C(); // error name is missing
-a = B; // error name is missing
+a = new C(); // error prop is missing
+a = B; // error prop is missing
 a = C;
 
-var b: B = new C(); // error name is missing
-b = B; // error name is missing
+var b: B = new C(); // error prop is missing
+b = B; // error prop is missing
 b = C;
 b = a;
 
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
index 0f260673d9d..5eb09ddb2d3 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
@@ -1,26 +1,56 @@
 // @target: es5   
 
 // static name
-class A {
+class StaticName {
     static name: number; // error
     name: string; // ok
 }
 
-class B {
+class StaticNameFn {
     static name() {} // error
     name() {} // ok
 }
 
 
-
-// static length...
-class C {
+class StaticLength {
     static length: number; // error
     length: string; // ok
 }
 
-class D {
+class StaticLengthFn {
     static length() {} // error
     length() {} // ok
 }
 
+
+class StaticPrototype {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+class StaticPrototypeFn {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+
+class StaticCaller {
+    static caller: number; // error
+    caller: string; // ok
+}
+
+class StaticCallerFn {
+    static caller() {} // error
+    caller() {} // ok
+}
+
+
+class StaticArguments {
+    static arguments: number; // error
+    arguments: string; // ok
+}
+
+class StaticArgumentsFn {
+    static arguments() {} // error
+    arguments() {} // ok
+}
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
index 47c7dbbde25..2122e183ff2 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
@@ -1,25 +1,56 @@
 // @target: es6
 
 
-// static name
-class A {
-    static name: string; // ok
+class StaticName {
+    static name: number; // ok
     name: string; // ok
 }
 
-class B {
-    static name() {}; // ok
-    name() {}; // ok
+class StaticNameFn {
+    static name() {} // ok
+    name() {} // ok
 }
 
 
-// static length
-class C {
+class StaticLength {
     static length: number; // ok
     length: string; // ok
 }
 
-class D {
+class StaticLengthFn {
     static length() {} // ok
     length() {} // ok
 }
+
+
+class StaticPrototype {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+class StaticPrototypeFn {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+
+class StaticCaller {
+    static caller: number; // // error
+    caller: string; // ok
+}
+
+class StaticCallerFn {
+    static caller() {} // // error
+    caller() {} // ok
+}
+
+
+class StaticArguments {
+    static arguments: number; // // error
+    arguments: string; // ok
+}
+
+class StaticArgumentsFn {
+    static arguments() {} // // error
+    arguments() {} // ok
+}

From 2bb4abce47c36f77abb59770e17a1f1ff59b4b42 Mon Sep 17 00:00:00 2001
From: Yui T <yuisu@microsoft.com>
Date: Mon, 17 Oct 2016 09:12:08 -0700
Subject: [PATCH 003/159] Use collator when making comparison as it is more
 performance than String.prototype.localeCompare

---
 src/compiler/core.ts          | 13 +++++++++----
 src/services/navigationBar.ts | 22 +---------------------
 2 files changed, 10 insertions(+), 25 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index befa30b6006..f34e9af58ba 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -21,7 +21,9 @@ namespace ts {
     const createObject = Object.create;
 
     // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
-    export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
+    export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator(/*locales*/ undefined, { usage: "sort", sensitivity: "accent" }) : undefined;
+    // Intl is missing in Safari, and node 0.10 treats "a" as greater than "B".
+    export const localeCompareIsCorrect = ts.collator && ts.collator.compare("a", "B") < 0;
 
     export function createMap<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
@@ -1050,9 +1052,12 @@ namespace ts {
         if (a === undefined) return Comparison.LessThan;
         if (b === undefined) return Comparison.GreaterThan;
         if (ignoreCase) {
-            if (collator && String.prototype.localeCompare) {
-                // accent means a ≠ b, a ≠ á, a = A
-                const result = a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });
+            // Checking if "collator exists indicates that Intl is available.
+            // We still have to check if "collator.compare" is correct. If it is not, use "String.localeComapre"
+            if (collator) {
+                const result = localeCompareIsCorrect ?
+                    collator.compare(a, b) :
+                    a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });  // accent means a ≠ b, a ≠ á, a = A
                 return result < 0 ? Comparison.LessThan : result > 0 ? Comparison.GreaterThan : Comparison.EqualTo;
             }
 
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index 7b4fb8cdba6..ce47d814e51 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -322,7 +322,7 @@ namespace ts.NavigationBar {
     function compareChildren(child1: NavigationBarNode, child2: NavigationBarNode): number {
         const name1 = tryGetName(child1.node), name2 = tryGetName(child2.node);
         if (name1 && name2) {
-            const cmp = localeCompareFix(name1, name2);
+            const cmp = ts.compareStringsCaseInsensitive(name1, name2);
             return cmp !== 0 ? cmp : navigationBarNodeKind(child1) - navigationBarNodeKind(child2);
         }
         else {
@@ -330,26 +330,6 @@ namespace ts.NavigationBar {
         }
     }
 
-    // Intl is missing in Safari, and node 0.10 treats "a" as greater than "B".
-    const localeCompareIsCorrect = ts.collator && ts.collator.compare("a", "B") < 0;
-    const localeCompareFix: (a: string, b: string) => number = localeCompareIsCorrect ? collator.compare : function(a, b) {
-        // This isn't perfect, but it passes all of our tests.
-        for (let i = 0; i < Math.min(a.length, b.length); i++) {
-            const chA = a.charAt(i), chB = b.charAt(i);
-            if (chA === "\"" && chB === "'") {
-                return 1;
-            }
-            if (chA === "'" && chB === "\"") {
-                return -1;
-            }
-            const cmp = ts.compareStrings(chA.toLocaleLowerCase(), chB.toLocaleLowerCase());
-            if (cmp !== 0) {
-                return cmp;
-            }
-        }
-        return a.length - b.length;
-    };
-
     /**
      * This differs from getItemName because this is just used for sorting.
      * We only sort nodes by name that have a more-or-less "direct" name, as opposed to `new()` and the like.

From 45e8a5b54d0e3fe8deb1f412436a9defad0ff04e Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Mon, 17 Oct 2016 19:22:40 +0200
Subject: [PATCH 004/159] Accepting new baseline. Format code to fit linter
 rules.

---
 src/compiler/checker.ts                       | 53 ++++++++++---------
 .../propertyNamedPrototype.errors.txt         |  4 +-
 .../staticPropertyNameConflictsEs5.errors.txt | 40 +++++++-------
 .../staticPropertyNameConflictsEs6.errors.txt | 24 ++++-----
 .../staticPrototypeProperty.errors.txt        |  8 +--
 5 files changed, 66 insertions(+), 63 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2412faed6ad..9e8c92309b0 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14554,43 +14554,46 @@ namespace ts {
 
         // Static members may conflict with non-configurable non-writable built-in Function.prototype properties 
         // see https://github.com/microsoft/typescript/issues/442.
-        function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) { 
+        function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) {
             const es5_descriptors: PropertyDescriptorMap = {
                 // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
                 // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
-                "name":      {configurable: false, writable: false},
-                "length":    {configurable: false, writable: false},
-                "prototype": {configurable: false, writable: false},
+                "name":      { configurable: false, writable: false },
+                "length":    { configurable: false, writable: false },
+                "prototype": { configurable: false, writable: false },
 
                 // see https://github.com/microsoft/typescript/issues/442
-                "caller":    {configurable: false, writable: false},
-                "arguments": {configurable: false, writable: false}
-            }; 
+                "caller":    { configurable: false, writable: false },
+                "arguments": { configurable: false, writable: false }
+            };
             const post_es5_descriptors: PropertyDescriptorMap = {
                 // see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
                 // see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
-                "name":      {configurable: true,  writable: false},
-                "length":    {configurable: true,  writable: false},
-                "prototype": {configurable: false, writable: false},
-                "caller":    {configurable: false, writable: false},
-                "arguments": {configurable: false, writable: false}
+                "name":      { configurable: true,  writable: false },
+                "length":    { configurable: true,  writable: false },
+                "prototype": { configurable: false, writable: false },
+                "caller":    { configurable: false, writable: false },
+                "arguments": { configurable: false, writable: false }
             };
             const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
             const className = getSymbolOfNode(node).name;
-            
-            for (let member of node.members) {
-                let isStatic = forEach(member.modifiers, (m:Modifier) => m.kind === SyntaxKind.StaticKeyword);
+
+            for (const member of node.members) {
+                const isStatic = forEach(member.modifiers, (m: Modifier) => m.kind === SyntaxKind.StaticKeyword);
                 if (isStatic) {
-                    let memberNameNode = member.name;
-                    let memberName = getPropertyNameForPropertyNameNode(memberNameNode);
-                    let descriptor: PropertyDescriptor = null;
-                    if (languageVersion <= ScriptTarget.ES5) {
-                        descriptor = es5_descriptors.hasOwnProperty(memberName) ? es5_descriptors[memberName] : null;
-                    } else if (languageVersion > ScriptTarget.ES5) {
-                        descriptor = post_es5_descriptors.hasOwnProperty(memberName) ? post_es5_descriptors[memberName] : null;                           
-                    }
-                    if (descriptor && descriptor.configurable === false && descriptor.writable === false) { 
-                        error(memberNameNode, message, memberName, className);
+                    const memberNameNode = member.name;
+                    if (memberNameNode) {
+                        const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
+                        let descriptor: PropertyDescriptor = undefined;
+                        if (languageVersion <= ScriptTarget.ES5) {
+                            descriptor = es5_descriptors.hasOwnProperty(memberName) ? es5_descriptors[memberName] : undefined;
+                        }
+                        else if (languageVersion > ScriptTarget.ES5) {
+                            descriptor = post_es5_descriptors.hasOwnProperty(memberName) ? post_es5_descriptors[memberName] : undefined;
+                        }
+                        if (descriptor && descriptor.configurable === false && descriptor.writable === false) {
+                            error(memberNameNode, message, memberName, className);
+                        }
                     }
                 }
             }
diff --git a/tests/baselines/reference/propertyNamedPrototype.errors.txt b/tests/baselines/reference/propertyNamedPrototype.errors.txt
index 6ddd8390720..2c0c8f30f76 100644
--- a/tests/baselines/reference/propertyNamedPrototype.errors.txt
+++ b/tests/baselines/reference/propertyNamedPrototype.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts(3,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts(3,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts (1 errors) ====
@@ -6,5 +6,5 @@ tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototyp
         prototype: number; // ok
         static prototype: C; // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
index 182b1628522..5c3f3b3f7dc 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts (11 errors) ====
@@ -17,14 +17,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticName {
         static name: number; // error
                ~~~~
-!!! error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+!!! error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
         name: string; // ok
     }
     
     class StaticNameFn {
         static name() {} // error
                ~~~~
-!!! error TS2692: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+!!! error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
         name() {} // ok
     }
     
@@ -32,14 +32,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticLength {
         static length: number; // error
                ~~~~~~
-!!! error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+!!! error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
         length: string; // ok
     }
     
     class StaticLengthFn {
         static length() {} // error
                ~~~~~~
-!!! error TS2692: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+!!! error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
         length() {} // ok
     }
     
@@ -47,7 +47,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticPrototype {
         static prototype: number; // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
         prototype: string; // ok
     }
     
@@ -56,7 +56,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
                ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
                ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
         prototype() {} // ok
     }
     
@@ -64,14 +64,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticCaller {
         static caller: number; // error
                ~~~~~~
-!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
         caller: string; // ok
     }
     
     class StaticCallerFn {
         static caller() {} // error
                ~~~~~~
-!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
         caller() {} // ok
     }
     
@@ -79,14 +79,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticArguments {
         static arguments: number; // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
         arguments: string; // ok
     }
     
     class StaticArgumentsFn {
         static arguments() {} // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
         arguments() {} // ok
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
index b76b7e02b76..0c65494c7bc 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
@@ -35,7 +35,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticPrototype {
         static prototype: number; // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
         prototype: string; // ok
     }
     
@@ -44,7 +44,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
                ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
                ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
         prototype() {} // ok
     }
     
@@ -52,14 +52,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticCaller {
         static caller: number; // // error
                ~~~~~~
-!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
         caller: string; // ok
     }
     
     class StaticCallerFn {
         static caller() {} // // error
                ~~~~~~
-!!! error TS2692: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
         caller() {} // ok
     }
     
@@ -67,14 +67,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticArguments {
         static arguments: number; // // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
         arguments: string; // ok
     }
     
     class StaticArgumentsFn {
         static arguments() {} // // error
                ~~~~~~~~~
-!!! error TS2692: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
         arguments() {} // ok
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPrototypeProperty.errors.txt b/tests/baselines/reference/staticPrototypeProperty.errors.txt
index b2f36a40bed..44b6980cb91 100644
--- a/tests/baselines/reference/staticPrototypeProperty.errors.txt
+++ b/tests/baselines/reference/staticPrototypeProperty.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
-tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
+tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
 
 
 ==== tests/cases/compiler/staticPrototypeProperty.ts (3 errors) ====
@@ -9,11 +9,11 @@ tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2692: Static prop
               ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
               ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
     }
      
     class C2 {
        static prototype;
               ~~~~~~~~~
-!!! error TS2692: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
+!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
     }
\ No newline at end of file

From 189dbddb101a0d5acaa612013d8cdd07ece78344 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sat, 5 Nov 2016 18:42:53 +0100
Subject: [PATCH 005/159] Accept baseline tests. Fixing
 `diagnosticMessages.json` (merge result not included in prior commit).

---
 src/compiler/diagnosticMessages.json          | 12 ++----
 .../propertyNamedPrototype.errors.txt         |  4 +-
 .../staticPropertyNameConflictsEs5.errors.txt | 40 +++++++++----------
 .../staticPropertyNameConflictsEs6.errors.txt | 32 +++++++--------
 .../staticPropertyNameConflictsEs6.js         | 12 +++---
 .../staticPrototypeProperty.errors.txt        |  8 ++--
 ...ariableDeclarationInStrictMode1.errors.txt |  2 +-
 .../staticPropertyNameConflictsEs6.ts         |  8 ++--
 8 files changed, 57 insertions(+), 61 deletions(-)

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 77df2489fe5..4bb683865a8 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1979,18 +1979,14 @@
         "category": "Error",
         "code": 2696
     },
-<<<<<<< HEAD
-    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
-        "category": "Error",
-        "code": 2699
-    },
-=======
     "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option.": {
         "category": "Error",
         "code": 2697
     },
-
->>>>>>> upstream/master
+    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
+        "category": "Error",
+        "code": 2699
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
diff --git a/tests/baselines/reference/propertyNamedPrototype.errors.txt b/tests/baselines/reference/propertyNamedPrototype.errors.txt
index 2c0c8f30f76..d80e1c95c8d 100644
--- a/tests/baselines/reference/propertyNamedPrototype.errors.txt
+++ b/tests/baselines/reference/propertyNamedPrototype.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts(3,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts(3,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototype.ts (1 errors) ====
@@ -6,5 +6,5 @@ tests/cases/conformance/classes/propertyMemberDeclarations/propertyNamedPrototyp
         prototype: number; // ok
         static prototype: C; // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
index 5c3f3b3f7dc..004365d3e76 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts (11 errors) ====
@@ -17,14 +17,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticName {
         static name: number; // error
                ~~~~
-!!! error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
         name: string; // ok
     }
     
     class StaticNameFn {
         static name() {} // error
                ~~~~
-!!! error TS2697: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
         name() {} // ok
     }
     
@@ -32,14 +32,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticLength {
         static length: number; // error
                ~~~~~~
-!!! error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
         length: string; // ok
     }
     
     class StaticLengthFn {
         static length() {} // error
                ~~~~~~
-!!! error TS2697: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
         length() {} // ok
     }
     
@@ -47,7 +47,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticPrototype {
         static prototype: number; // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
         prototype: string; // ok
     }
     
@@ -56,7 +56,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
                ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
                ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
         prototype() {} // ok
     }
     
@@ -64,14 +64,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticCaller {
         static caller: number; // error
                ~~~~~~
-!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
         caller: string; // ok
     }
     
     class StaticCallerFn {
         static caller() {} // error
                ~~~~~~
-!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
         caller() {} // ok
     }
     
@@ -79,14 +79,14 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticArguments {
         static arguments: number; // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
         arguments: string; // ok
     }
     
     class StaticArgumentsFn {
         static arguments() {} // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
         arguments() {} // ok
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
index 0c65494c7bc..ef83151aa3d 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
 
 
 ==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
@@ -35,7 +35,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     class StaticPrototype {
         static prototype: number; // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
         prototype: string; // ok
     }
     
@@ -44,37 +44,37 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
                ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
                ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
         prototype() {} // ok
     }
     
     
     class StaticCaller {
-        static caller: number; // // error
+        static caller: number; // error
                ~~~~~~
-!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
         caller: string; // ok
     }
     
     class StaticCallerFn {
-        static caller() {} // // error
+        static caller() {} // error
                ~~~~~~
-!!! error TS2697: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
         caller() {} // ok
     }
     
     
     class StaticArguments {
-        static arguments: number; // // error
+        static arguments: number; // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
         arguments: string; // ok
     }
     
     class StaticArgumentsFn {
-        static arguments() {} // // error
+        static arguments() {} // error
                ~~~~~~~~~
-!!! error TS2697: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
         arguments() {} // ok
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.js b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
index 67756c37a92..48e8b7a063d 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.js
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
@@ -35,23 +35,23 @@ class StaticPrototypeFn {
 
 
 class StaticCaller {
-    static caller: number; // // error
+    static caller: number; // error
     caller: string; // ok
 }
 
 class StaticCallerFn {
-    static caller() {} // // error
+    static caller() {} // error
     caller() {} // ok
 }
 
 
 class StaticArguments {
-    static arguments: number; // // error
+    static arguments: number; // error
     arguments: string; // ok
 }
 
 class StaticArgumentsFn {
-    static arguments() {} // // error
+    static arguments() {} // error
     arguments() {} // ok
 }
 
@@ -78,12 +78,12 @@ class StaticPrototypeFn {
 class StaticCaller {
 }
 class StaticCallerFn {
-    static caller() { } // // error
+    static caller() { } // error
     caller() { } // ok
 }
 class StaticArguments {
 }
 class StaticArgumentsFn {
-    static arguments() { } // // error
+    static arguments() { } // error
     arguments() { } // ok
 }
diff --git a/tests/baselines/reference/staticPrototypeProperty.errors.txt b/tests/baselines/reference/staticPrototypeProperty.errors.txt
index 44b6980cb91..c131b7a774d 100644
--- a/tests/baselines/reference/staticPrototypeProperty.errors.txt
+++ b/tests/baselines/reference/staticPrototypeProperty.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
-tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
+tests/cases/compiler/staticPrototypeProperty.ts(2,11): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
 
 
 ==== tests/cases/compiler/staticPrototypeProperty.ts (3 errors) ====
@@ -9,11 +9,11 @@ tests/cases/compiler/staticPrototypeProperty.ts(6,11): error TS2697: Static prop
               ~~~~~~~~~
 !!! error TS2300: Duplicate identifier 'prototype'.
               ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C'.
     }
      
     class C2 {
        static prototype;
               ~~~~~~~~~
-!!! error TS2697: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'C2'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
index 46782aaa1d6..9dd9a8d41a1 100644
--- a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
+++ b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
@@ -1,4 +1,4 @@
-lib.d.ts(32,18): error TS2300: Duplicate identifier 'eval'.
+lib.d.ts(28,18): error TS2300: Duplicate identifier 'eval'.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS1100: Invalid use of 'eval' in strict mode.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS2300: Duplicate identifier 'eval'.
 
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
index 2122e183ff2..412833791b4 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
@@ -35,22 +35,22 @@ class StaticPrototypeFn {
 
 
 class StaticCaller {
-    static caller: number; // // error
+    static caller: number; // error
     caller: string; // ok
 }
 
 class StaticCallerFn {
-    static caller() {} // // error
+    static caller() {} // error
     caller() {} // ok
 }
 
 
 class StaticArguments {
-    static arguments: number; // // error
+    static arguments: number; // error
     arguments: string; // ok
 }
 
 class StaticArgumentsFn {
-    static arguments() {} // // error
+    static arguments() {} // error
     arguments() {} // ok
 }

From d58b5c807cffd71e65d6c26ac45e1858427f062c Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sun, 6 Nov 2016 00:36:41 +0100
Subject: [PATCH 006/159] Fixing wrong line number in
 tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt after
 rebuilding and testing compiler.

---
 .../reference/variableDeclarationInStrictMode1.errors.txt       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
index 9dd9a8d41a1..46782aaa1d6 100644
--- a/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
+++ b/tests/baselines/reference/variableDeclarationInStrictMode1.errors.txt
@@ -1,4 +1,4 @@
-lib.d.ts(28,18): error TS2300: Duplicate identifier 'eval'.
+lib.d.ts(32,18): error TS2300: Duplicate identifier 'eval'.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS1100: Invalid use of 'eval' in strict mode.
 tests/cases/compiler/variableDeclarationInStrictMode1.ts(2,5): error TS2300: Duplicate identifier 'eval'.
 

From d9a46e1ae6877e4fe806fe2592d043d330ea2893 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sun, 6 Nov 2016 17:59:38 +0100
Subject: [PATCH 007/159] Allowing `static arguments()` and `static caller()`
 for target `"es6"`. Disallow non-function properties `static arguments` and
 `static caller`, though.

---
 src/compiler/checker.ts                       | 64 +++++++++----------
 .../staticPropertyNameConflictsEs6.errors.txt | 12 +---
 .../staticPropertyNameConflictsEs6.js         |  8 +--
 .../staticPropertyNameConflictsEs6.ts         |  4 +-
 4 files changed, 38 insertions(+), 50 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6524a69f13f..d756f215ac3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14764,49 +14764,43 @@ namespace ts {
             }
         }
 
-        // Static members may conflict with non-configurable non-writable built-in Function.prototype properties 
+        // Static members may conflict with non-configurable non-writable built-in Function object properties 
         // see https://github.com/microsoft/typescript/issues/442.
         function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) {
-            const es5_descriptors: PropertyDescriptorMap = {
-                // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
-                // see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
-                "name":      { configurable: false, writable: false },
-                "length":    { configurable: false, writable: false },
-                "prototype": { configurable: false, writable: false },
-
-                // see https://github.com/microsoft/typescript/issues/442
-                "caller":    { configurable: false, writable: false },
-                "arguments": { configurable: false, writable: false }
-            };
-            const post_es5_descriptors: PropertyDescriptorMap = {
-                // see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
-                // see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
-                "name":      { configurable: true,  writable: false },
-                "length":    { configurable: true,  writable: false },
-                "prototype": { configurable: false, writable: false },
-                "caller":    { configurable: false, writable: false },
-                "arguments": { configurable: false, writable: false }
-            };
             const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
             const className = getSymbolOfNode(node).name;
-
             for (const member of node.members) {
-                const isStatic = forEach(member.modifiers, (m: Modifier) => m.kind === SyntaxKind.StaticKeyword);
-                if (isStatic) {
-                    const memberNameNode = member.name;
-                    if (memberNameNode) {
-                        const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
-                        let descriptor: PropertyDescriptor = undefined;
-                        if (languageVersion <= ScriptTarget.ES5) {
-                            descriptor = es5_descriptors.hasOwnProperty(memberName) ? es5_descriptors[memberName] : undefined;
-                        }
-                        else if (languageVersion > ScriptTarget.ES5) {
-                            descriptor = post_es5_descriptors.hasOwnProperty(memberName) ? post_es5_descriptors[memberName] : undefined;
-                        }
-                        if (descriptor && descriptor.configurable === false && descriptor.writable === false) {
+                const isStatic = forEach(member.modifiers, (m: Modifier) => m.kind  === SyntaxKind.StaticKeyword);
+                const isMethod = member.kind === SyntaxKind.MethodDeclaration;
+                const memberNameNode = member.name;
+                if (isStatic && memberNameNode) {
+                    const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
+                    if (languageVersion <= ScriptTarget.ES5) {  // ES3, ES5
+                        // see also http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
+                        // see also http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
+                        if (memberName === "prototype" ||
+                            memberName === "name" ||
+                            memberName === "length" ||
+                            memberName === "caller" ||
+                            memberName === "arguments"
+                        ) {
                             error(memberNameNode, message, memberName, className);
                         }
                     }
+                    else { // ES6+
+                        // see also http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
+                        // see also http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
+                        if (memberName === "prototype") {
+                            error(memberNameNode, message, memberName, className);
+                        }
+                        else if ((
+                            memberName === "caller" ||
+                            memberName === "arguments" ) &&
+                            isMethod === false
+                        ) {
+                           error(memberNameNode, message, memberName, className);
+                        }
+                    }
                 }
             }
         }
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
index ef83151aa3d..b73b01abbbe 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
@@ -2,12 +2,10 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(42,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(53,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
 
 
-==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
+==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (5 errors) ====
     
     
     class StaticName {
@@ -57,9 +55,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     }
     
     class StaticCallerFn {
-        static caller() {} // error
-               ~~~~~~
-!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+        static caller() {} // ok
         caller() {} // ok
     }
     
@@ -72,9 +68,7 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
     }
     
     class StaticArgumentsFn {
-        static arguments() {} // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+        static arguments() {} // ok
         arguments() {} // ok
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.js b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
index 48e8b7a063d..8d96c73d4c5 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.js
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
@@ -40,7 +40,7 @@ class StaticCaller {
 }
 
 class StaticCallerFn {
-    static caller() {} // error
+    static caller() {} // ok
     caller() {} // ok
 }
 
@@ -51,7 +51,7 @@ class StaticArguments {
 }
 
 class StaticArgumentsFn {
-    static arguments() {} // error
+    static arguments() {} // ok
     arguments() {} // ok
 }
 
@@ -78,12 +78,12 @@ class StaticPrototypeFn {
 class StaticCaller {
 }
 class StaticCallerFn {
-    static caller() { } // error
+    static caller() { } // ok
     caller() { } // ok
 }
 class StaticArguments {
 }
 class StaticArgumentsFn {
-    static arguments() { } // error
+    static arguments() { } // ok
     arguments() { } // ok
 }
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
index 412833791b4..01db0c27872 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
@@ -40,7 +40,7 @@ class StaticCaller {
 }
 
 class StaticCallerFn {
-    static caller() {} // error
+    static caller() {} // ok
     caller() {} // ok
 }
 
@@ -51,6 +51,6 @@ class StaticArguments {
 }
 
 class StaticArgumentsFn {
-    static arguments() {} // error
+    static arguments() {} // ok
     arguments() {} // ok
 }

From b623f3771e91f5fe31c498c9a5defc4172b567bd Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Wed, 9 Nov 2016 21:08:56 +0100
Subject: [PATCH 008/159] Fix #442: (es3, es5, es6+) Show compiler errors for
 conflicting properties.

---
 src/compiler/checker.ts                            |  6 ++++--
 .../staticPropertyNameConflictsEs6.errors.txt      | 14 ++++++++++----
 .../reference/staticPropertyNameConflictsEs6.js    |  6 +++---
 .../staticPropertyNameConflictsEs6.ts              |  6 +++---
 4 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d756f215ac3..de82ee004e8 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14794,11 +14794,13 @@ namespace ts {
                             error(memberNameNode, message, memberName, className);
                         }
                         else if ((
+                            memberName === "name" ||
+                            memberName === "length" ||
                             memberName === "caller" ||
-                            memberName === "arguments" ) &&
+                            memberName === "arguments") &&
                             isMethod === false
                         ) {
-                           error(memberNameNode, message, memberName, className);
+                            error(memberNameNode, message, memberName, className);
                         }
                     }
                 }
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
index b73b01abbbe..607735bb12f 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
@@ -1,3 +1,5 @@
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(4,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(15,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
@@ -5,22 +7,26 @@ tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameCon
 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
 
 
-==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (5 errors) ====
+==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
     
     
     class StaticName {
-        static name: number; // ok
+        static name: number; // error
+               ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
         name: string; // ok
     }
     
     class StaticNameFn {
-        static name() {} // ok
+        static name() {}  // ok
         name() {} // ok
     }
     
     
     class StaticLength {
-        static length: number; // ok
+        static length: number;  // error
+               ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
         length: string; // ok
     }
     
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.js b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
index 8d96c73d4c5..7adef10b141 100644
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.js
+++ b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
@@ -2,18 +2,18 @@
 
 
 class StaticName {
-    static name: number; // ok
+    static name: number; // error
     name: string; // ok
 }
 
 class StaticNameFn {
-    static name() {} // ok
+    static name() {}  // ok
     name() {} // ok
 }
 
 
 class StaticLength {
-    static length: number; // ok
+    static length: number;  // error
     length: string; // ok
 }
 
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
index 01db0c27872..1b93e98dae8 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
@@ -2,18 +2,18 @@
 
 
 class StaticName {
-    static name: number; // ok
+    static name: number; // error
     name: string; // ok
 }
 
 class StaticNameFn {
-    static name() {} // ok
+    static name() {}  // ok
     name() {} // ok
 }
 
 
 class StaticLength {
-    static length: number; // ok
+    static length: number;  // error
     length: string; // ok
 }
 

From 39eb187e5c530ac1124bfeefd7c2c811493e55de Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <Daniel.Rosenwasser@microsoft.com>
Date: Fri, 11 Nov 2016 01:22:06 -0800
Subject: [PATCH 009/159] Added diagnostic.

---
 src/compiler/diagnosticMessages.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 9a353e6fb36..1ae59b61acc 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -3159,6 +3159,10 @@
         "category": "Message",
         "code": 90007
     },
+    "Add 'this.' to unresolved variable.": {
+        "category": "Message",
+        "code": 90008
+    },
     "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig": {
         "category": "Error",
         "code": 90009

From da356b075a4829e616bebe26196c5944ac9393c9 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <Daniel.Rosenwasser@microsoft.com>
Date: Fri, 11 Nov 2016 01:25:50 -0800
Subject: [PATCH 010/159] Added tests for missing 'this' property accesses.

---
 tests/cases/fourslash/codeFixAddForgottenThis01.ts | 10 ++++++++++
 tests/cases/fourslash/codeFixAddForgottenThis02.ts |  9 +++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 tests/cases/fourslash/codeFixAddForgottenThis01.ts
 create mode 100644 tests/cases/fourslash/codeFixAddForgottenThis02.ts

diff --git a/tests/cases/fourslash/codeFixAddForgottenThis01.ts b/tests/cases/fourslash/codeFixAddForgottenThis01.ts
new file mode 100644
index 00000000000..90d191b6ba5
--- /dev/null
+++ b/tests/cases/fourslash/codeFixAddForgottenThis01.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+////class C {
+////    foo: number;
+////    constructor() {
+////        [|foo = 10|];
+////    }
+////}
+
+verify.rangeAfterCodeFix("this.foo = 10");
\ No newline at end of file
diff --git a/tests/cases/fourslash/codeFixAddForgottenThis02.ts b/tests/cases/fourslash/codeFixAddForgottenThis02.ts
new file mode 100644
index 00000000000..b387f349073
--- /dev/null
+++ b/tests/cases/fourslash/codeFixAddForgottenThis02.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+////class C {
+////    constructor(public foo) {
+////    }
+////    bar() { [|foo = 10|] };
+////}
+
+verify.rangeAfterCodeFix("this.foo = 10");
\ No newline at end of file

From f2c0aa4444db61ee3870c6d3dc7b8cb74cc44e05 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <Daniel.Rosenwasser@microsoft.com>
Date: Fri, 11 Nov 2016 01:27:26 -0800
Subject: [PATCH 011/159] Added fix for missing 'this.' property accesses.

---
 .../codefixes/fixForgottenThisPropertyAccess.ts  | 16 ++++++++++++++++
 src/services/codefixes/fixes.ts                  |  3 ++-
 src/services/tsconfig.json                       |  3 ++-
 3 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 src/services/codefixes/fixForgottenThisPropertyAccess.ts

diff --git a/src/services/codefixes/fixForgottenThisPropertyAccess.ts b/src/services/codefixes/fixForgottenThisPropertyAccess.ts
new file mode 100644
index 00000000000..c9d59dd8337
--- /dev/null
+++ b/src/services/codefixes/fixForgottenThisPropertyAccess.ts
@@ -0,0 +1,16 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const token = getTokenAtPosition(sourceFile, context.span.start);
+            const start = token.getStart(sourceFile);
+
+            return [{
+                description: getLocaleSpecificMessage(Diagnostics.Add_this_to_unresolved_variable),
+                changes: [{ fileName: sourceFile.fileName, textChanges: [{ newText: "this.", span: { start, length: 0 } }] }]
+            }];
+        }
+    });
+}
\ No newline at end of file
diff --git a/src/services/codefixes/fixes.ts b/src/services/codefixes/fixes.ts
index 982b6abc84b..da51f04ff8c 100644
--- a/src/services/codefixes/fixes.ts
+++ b/src/services/codefixes/fixes.ts
@@ -3,4 +3,5 @@
 /// <reference path="fixClassSuperMustPrecedeThisAccess.ts" />
 /// <reference path="fixConstructorForDerivedNeedSuperCall.ts" />
 /// <reference path="fixExtendsInterfaceBecomesImplements.ts" />
-/// <reference path="fixRemoveAbstractModifierInNonAbstractClass.ts" />
\ No newline at end of file
+/// <reference path="fixRemoveAbstractModifierInNonAbstractClass.ts" />
+/// <reference path="fixForgottenThisPropertyAccess.ts" />
\ No newline at end of file
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index 69efe29ba39..699ffcd7612 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -91,6 +91,7 @@
         "codeFixes/fixClassIncorrectlyImplementsInterface.ts",
         "codeFixes/fixClassDoesntImplementInheritedAbstractMember.ts",
         "codeFixes/fixClassSuperMustPrecedeThisAccess.ts",
-        "codeFixes/fixConstructorForDerivedNeedSuperCall.ts"
+        "codeFixes/fixConstructorForDerivedNeedSuperCall.ts",
+        "codefixes/fixForgottenThisPropertyAccess.ts"
     ]
 }

From b220831ab7a89fd7e03889911cea738e9daafd31 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 29 Nov 2016 07:01:31 -0800
Subject: [PATCH 012/159] Sort matched files by include order

---
 src/compiler/commandLineParser.ts             |   1 -
 src/compiler/core.ts                          | 123 +++++++++++-------
 src/harness/unittests/matchFiles.ts           |  52 ++++++--
 .../nodeModulesMaxDepthExceeded.errors.txt    |  20 +--
 .../amd/nodeModulesMaxDepthExceeded.json      |   4 +-
 .../nodeModulesMaxDepthExceeded.errors.txt    |  20 +--
 .../node/nodeModulesMaxDepthExceeded.json     |   4 +-
 7 files changed, 141 insertions(+), 83 deletions(-)

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 3c6a86134ea..a81698469e7 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -1264,7 +1264,6 @@ namespace ts {
 
         const literalFiles = reduceProperties(literalFileMap, addFileToOutput, []);
         const wildcardFiles = reduceProperties(wildcardFileMap, addFileToOutput, []);
-        wildcardFiles.sort(host.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
         return {
             fileNames: literalFiles.concat(wildcardFiles),
             wildcardDirectories
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 89057dd2939..8406404132d 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1668,7 +1668,19 @@ namespace ts {
     const singleAsteriskRegexFragmentFiles = "([^./]|(\\.(?!min\\.js$))?)*";
     const singleAsteriskRegexFragmentOther = "[^/]*";
 
-    export function getRegularExpressionForWildcard(specs: string[], basePath: string, usage: "files" | "directories" | "exclude") {
+    export function getRegularExpressionForWildcard(specs: string[], basePath: string, usage: "files" | "directories" | "exclude"): string | undefined {
+        const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
+        if (!patterns || !patterns.length) {
+            return undefined;
+        }
+
+        const pattern = patterns.map(pattern => `(${pattern})`).join("|");
+        // If excluding, match "foo/bar/baz...", but if including, only allow "foo".
+        const terminator = usage === "exclude" ? "($|/)" : "$";
+        return `^(${pattern})${terminator}`;
+    }
+
+    function getRegularExpressionsForWildcards(specs: string[], basePath: string, usage: "files" | "directories" | "exclude"): string[] | undefined {
         if (specs === undefined || specs.length === 0) {
             return undefined;
         }
@@ -1682,33 +1694,8 @@ namespace ts {
          */
         const doubleAsteriskRegexFragment = usage === "exclude" ? "(/.+?)?" : "(/[^/.][^/]*)*?";
 
-        let pattern = "";
-        let hasWrittenSubpattern = false;
-        for (const spec of specs) {
-            if (!spec) {
-                continue;
-            }
-
-            const subPattern = getSubPatternFromSpec(spec, basePath, usage, singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter);
-            if (subPattern === undefined) {
-                continue;
-            }
-
-            if (hasWrittenSubpattern) {
-                pattern += "|";
-            }
-
-            pattern += "(" + subPattern + ")";
-            hasWrittenSubpattern = true;
-        }
-
-        if (!pattern) {
-            return undefined;
-        }
-
-        // If excluding, match "foo/bar/baz...", but if including, only allow "foo".
-        const terminator = usage === "exclude" ? "($|/)" : "$";
-        return `^(${pattern})${terminator}`;
+        return flatMap(specs, spec =>
+            spec && getSubPatternFromSpec(spec, basePath, usage, singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter));
     }
 
     /**
@@ -1803,6 +1790,9 @@ namespace ts {
     }
 
     export interface FileMatcherPatterns {
+        /** One pattern for each "include" spec. */
+        includeFilePatterns: string[];
+        /** One pattern matching one of any of the "include" specs. */
         includeFilePattern: string;
         includeDirectoryPattern: string;
         excludePattern: string;
@@ -1815,6 +1805,7 @@ namespace ts {
         const absolutePath = combinePaths(currentDirectory, path);
 
         return {
+            includeFilePatterns: map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), pattern => `^${pattern}$`),
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
@@ -1829,38 +1820,76 @@ namespace ts {
         const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
 
         const regexFlag = useCaseSensitiveFileNames ? "" : "i";
-        const includeFileRegex = patterns.includeFilePattern && new RegExp(patterns.includeFilePattern, regexFlag);
+        const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(pattern => new RegExp(pattern, regexFlag));
         const includeDirectoryRegex = patterns.includeDirectoryPattern && new RegExp(patterns.includeDirectoryPattern, regexFlag);
         const excludeRegex = patterns.excludePattern && new RegExp(patterns.excludePattern, regexFlag);
 
-        const result: string[] = [];
+        // Associate an array of results with each include regex. This keeps results in order of the "include" order.
+        // If there are no "includes", then just put everything in results[0].
+        const results: string[][] = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
+
         for (const basePath of patterns.basePaths) {
-            visitDirectory(basePath, combinePaths(currentDirectory, basePath));
+            forEachFileInRecursiveDirectories(basePath, combinePaths(currentDirectory, basePath), { useCaseSensitiveFileNames, getFileSystemEntries, includeDirectory, visitFile });
         }
-        return result;
+
+        return flatten(results);
+
+        function includeDirectory(absoluteDirectoryName: string): boolean {
+            return (!includeDirectoryRegex || includeDirectoryRegex.test(absoluteDirectoryName)) &&
+                (!excludeRegex || !excludeRegex.test(absoluteDirectoryName));
+        }
+
+        function visitFile(fileName: string, absoluteFileName: string): void {
+            if (extensions && !fileExtensionIsAny(fileName, extensions) ||
+                excludeRegex && excludeRegex.test(absoluteFileName)) {
+                return;
+            }
+
+            if (!includeFileRegexes) {
+                results[0].push(fileName);
+            }
+            else {
+                for (let i = 0; i < includeFileRegexes.length; i++) {
+                    if (includeFileRegexes[i].test(absoluteFileName)) {
+                        results[i].push(fileName);
+                        // Only include a file once.
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    interface RecursiveDirectoryVisitor {
+        useCaseSensitiveFileNames: boolean;
+        getFileSystemEntries: (path: string) => FileSystemEntries;
+        includeDirectory: (absoluteDirectoryName: string) => boolean;
+        visitFile: (fileName: string, absoluteFileName: string) => void;
+    }
+
+    function forEachFileInRecursiveDirectories(start: string, absoluteStart: string, visitor: RecursiveDirectoryVisitor): void {
+        visitDirectory(start, absoluteStart);
 
         function visitDirectory(path: string, absolutePath: string) {
-            const { files, directories } = getFileSystemEntries(path);
+            let { files, directories } = visitor.getFileSystemEntries(path);
+            files = sorted(files);
+            directories = sorted(directories);
 
-            for (const current of files) {
-                const name = combinePaths(path, current);
-                const absoluteName = combinePaths(absolutePath, current);
-                if ((!extensions || fileExtensionIsAny(name, extensions)) &&
-                    (!includeFileRegex || includeFileRegex.test(absoluteName)) &&
-                    (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    result.push(name);
-                }
+            for (const file of files) {
+                visitor.visitFile(combinePaths(path, file), combinePaths(absolutePath, file));
             }
 
-            for (const current of directories) {
-                const name = combinePaths(path, current);
-                const absoluteName = combinePaths(absolutePath, current);
-                if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
-                    (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName);
+            for (const dir of directories) {
+                const absoluteName = combinePaths(absolutePath, dir);
+                if (visitor.includeDirectory(absoluteName)) {
+                    visitDirectory(combinePaths(path, dir), absoluteName);
                 }
             }
         }
+
+        function sorted(names: string[]): string[] {
+            return names.slice().sort(visitor.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
+        }
     }
 
     /**
diff --git a/src/harness/unittests/matchFiles.ts b/src/harness/unittests/matchFiles.ts
index c562fcefe91..00efe73c3e2 100644
--- a/src/harness/unittests/matchFiles.ts
+++ b/src/harness/unittests/matchFiles.ts
@@ -346,9 +346,9 @@ namespace ts {
                     fileNames: [
                         "c:/dev/a.ts",
                         "c:/dev/b.ts",
+                        "c:/dev/node_modules/a.ts",
                         "c:/dev/bower_components/a.ts",
-                        "c:/dev/jspm_packages/a.ts",
-                        "c:/dev/node_modules/a.ts"
+                        "c:/dev/jspm_packages/a.ts"
                     ],
                     wildcardDirectories: {},
                 };
@@ -373,9 +373,9 @@ namespace ts {
                     options: {},
                     errors: [],
                     fileNames: [
+                        "c:/dev/node_modules/a.ts",
                         "c:/dev/bower_components/a.ts",
-                        "c:/dev/jspm_packages/a.ts",
-                        "c:/dev/node_modules/a.ts"
+                        "c:/dev/jspm_packages/a.ts"
                     ],
                     wildcardDirectories: {},
                 };
@@ -398,9 +398,9 @@ namespace ts {
                     fileNames: [
                         "c:/dev/a.ts",
                         "c:/dev/b.ts",
+                        "c:/dev/node_modules/a.ts",
                         "c:/dev/bower_components/a.ts",
-                        "c:/dev/jspm_packages/a.ts",
-                        "c:/dev/node_modules/a.ts"
+                        "c:/dev/jspm_packages/a.ts"
                     ],
                     wildcardDirectories: {},
                 };
@@ -410,6 +410,36 @@ namespace ts {
         });
 
         describe("with wildcard include list", () => {
+            it("is sorted in include order, then in alphabetical order", () => {
+                const json = {
+                    include: [
+                        "z/*.ts",
+                        "x/*.ts"
+                    ]
+                };
+                const expected: ts.ParsedCommandLine = {
+                    options: {},
+                    errors: [],
+                    fileNames: [
+                        "c:/dev/z/a.ts",
+                        "c:/dev/z/aba.ts",
+                        "c:/dev/z/abz.ts",
+                        "c:/dev/z/b.ts",
+                        "c:/dev/z/bba.ts",
+                        "c:/dev/z/bbz.ts",
+                        "c:/dev/x/a.ts",
+                        "c:/dev/x/aa.ts",
+                        "c:/dev/x/b.ts"
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev/z": ts.WatchDirectoryFlags.None,
+                        "c:/dev/x": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveHost, caseInsensitiveBasePath);
+                assertParsed(actual, expected);
+            });
+
             it("same named declarations are excluded", () => {
                 const json = {
                     include: [
@@ -506,8 +536,8 @@ namespace ts {
                     options: {},
                     errors: [],
                     fileNames: [
-                        "c:/dev/x/a.ts",
                         "c:/dev/x/y/a.ts",
+                        "c:/dev/x/a.ts",
                         "c:/dev/z/a.ts"
                     ],
                     wildcardDirectories: {
@@ -1230,8 +1260,8 @@ namespace ts {
                         options: {},
                         errors: [],
                         fileNames: [
-                            "c:/dev/.z/.b.ts",
-                            "c:/dev/x/.y/a.ts"
+                            "c:/dev/x/.y/a.ts",
+                            "c:/dev/.z/.b.ts"
                         ],
                         wildcardDirectories: {}
                     };
@@ -1271,8 +1301,8 @@ namespace ts {
                         options: {},
                         errors: [],
                         fileNames: [
-                            "c:/dev/.z/.b.ts",
-                            "c:/dev/x/.y/a.ts"
+                            "c:/dev/x/.y/a.ts",
+                            "c:/dev/.z/.b.ts"
                         ],
                         wildcardDirectories: {
                             "c:/dev/.z": ts.WatchDirectoryFlags.Recursive,
diff --git a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.errors.txt b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.errors.txt
index 99e7b193f0c..5b5199ad7ae 100644
--- a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.errors.txt
+++ b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.errors.txt
@@ -2,19 +2,10 @@ maxDepthExceeded/root.ts(3,1): error TS2322: Type '"10"' is not assignable to ty
 maxDepthExceeded/root.ts(4,4): error TS2540: Cannot assign to 'rel' because it is a constant or a read-only property.
 
 
-==== entry.js (0 errors) ====
-    var m3 = require("m3");
-    
-    module.exports = {
-    	"a": 42,
-    	"b": "hello, world",
-    	"person": m3.person
-    };
-    
 ==== relative.js (0 errors) ====
     exports.relativeProp = true;
     
-==== maxDepthExceeded/node_modules/m1/index.js (0 errors) ====
+==== index.js (0 errors) ====
     var m2 = require('m2');
     var rel = require('./relative');
     
@@ -40,4 +31,13 @@ maxDepthExceeded/root.ts(4,4): error TS2540: Cannot assign to 'rel' because it i
 !!! error TS2540: Cannot assign to 'rel' because it is a constant or a read-only property.
     
     m1.f2.person.age = "10"; // OK if stopped at 2 modules: person will be "any".
+    
+==== entry.js (0 errors) ====
+    var m3 = require("m3");
+    
+    module.exports = {
+    	"a": 42,
+    	"b": "hello, world",
+    	"person": m3.person
+    };
     
\ No newline at end of file
diff --git a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.json b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.json
index 86e856dc7b8..9efa0e936ac 100644
--- a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.json
+++ b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/amd/nodeModulesMaxDepthExceeded.json
@@ -7,10 +7,10 @@
     "project": "maxDepthExceeded",
     "resolvedInputFiles": [
         "lib.d.ts",
-        "maxDepthExceeded/node_modules/m2/entry.js",
         "maxDepthExceeded/node_modules/m1/relative.js",
         "maxDepthExceeded/node_modules/m1/index.js",
-        "maxDepthExceeded/root.ts"
+        "maxDepthExceeded/root.ts",
+        "maxDepthExceeded/node_modules/m2/entry.js"
     ],
     "emittedFiles": [
         "maxDepthExceeded/built/node_modules/m1/relative.js",
diff --git a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.errors.txt b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.errors.txt
index 99e7b193f0c..5b5199ad7ae 100644
--- a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.errors.txt
+++ b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.errors.txt
@@ -2,19 +2,10 @@ maxDepthExceeded/root.ts(3,1): error TS2322: Type '"10"' is not assignable to ty
 maxDepthExceeded/root.ts(4,4): error TS2540: Cannot assign to 'rel' because it is a constant or a read-only property.
 
 
-==== entry.js (0 errors) ====
-    var m3 = require("m3");
-    
-    module.exports = {
-    	"a": 42,
-    	"b": "hello, world",
-    	"person": m3.person
-    };
-    
 ==== relative.js (0 errors) ====
     exports.relativeProp = true;
     
-==== maxDepthExceeded/node_modules/m1/index.js (0 errors) ====
+==== index.js (0 errors) ====
     var m2 = require('m2');
     var rel = require('./relative');
     
@@ -40,4 +31,13 @@ maxDepthExceeded/root.ts(4,4): error TS2540: Cannot assign to 'rel' because it i
 !!! error TS2540: Cannot assign to 'rel' because it is a constant or a read-only property.
     
     m1.f2.person.age = "10"; // OK if stopped at 2 modules: person will be "any".
+    
+==== entry.js (0 errors) ====
+    var m3 = require("m3");
+    
+    module.exports = {
+    	"a": 42,
+    	"b": "hello, world",
+    	"person": m3.person
+    };
     
\ No newline at end of file
diff --git a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.json b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.json
index 86e856dc7b8..9efa0e936ac 100644
--- a/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.json
+++ b/tests/baselines/reference/project/nodeModulesMaxDepthExceeded/node/nodeModulesMaxDepthExceeded.json
@@ -7,10 +7,10 @@
     "project": "maxDepthExceeded",
     "resolvedInputFiles": [
         "lib.d.ts",
-        "maxDepthExceeded/node_modules/m2/entry.js",
         "maxDepthExceeded/node_modules/m1/relative.js",
         "maxDepthExceeded/node_modules/m1/index.js",
-        "maxDepthExceeded/root.ts"
+        "maxDepthExceeded/root.ts",
+        "maxDepthExceeded/node_modules/m2/entry.js"
     ],
     "emittedFiles": [
         "maxDepthExceeded/built/node_modules/m1/relative.js",

From ca9f599563e6f089d34284efbf01ef46040ad7d8 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 5 Dec 2016 09:57:11 -0800
Subject: [PATCH 013/159] Property access for string index signatures

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 903c8cfda1c..4a575e014cd 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -12223,6 +12223,10 @@ namespace ts {
             }
             const prop = getPropertyOfType(apparentType, right.text);
             if (!prop) {
+                const stringIndexType = getIndexTypeOfType(apparentType, IndexKind.String);
+                if (stringIndexType) {
+                    return stringIndexType;
+                }
                 if (right.text && !checkAndReportErrorForExtendingInterface(node)) {
                     reportNonexistentProperty(right, type.flags & TypeFlags.TypeParameter && (type as TypeParameter).isThisType ? apparentType : type);
                 }

From a90d63a414473fb1f9faf8866e7e1b75fbbfe6f7 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 5 Dec 2016 09:58:09 -0800
Subject: [PATCH 014/159] Add tests for property access w/string index sigs

---
 .../propertyAccessStringIndexSignature.ts            | 11 +++++++++++
 ...ropertyAccessStringIndexSignatureNoImplicitAny.ts | 12 ++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts
 create mode 100644 tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts

diff --git a/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts b/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts
new file mode 100644
index 00000000000..7faf758bc9f
--- /dev/null
+++ b/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts
@@ -0,0 +1,11 @@
+interface Flags { [name: string]: boolean };
+let flags: Flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+
+interface Empty { }
+let empty: Empty;
+empty.nope;
+empty["that's ok"];
diff --git a/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts b/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts
new file mode 100644
index 00000000000..bfb64c6098a
--- /dev/null
+++ b/tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts
@@ -0,0 +1,12 @@
+// @noImplicitAny: true
+interface Flags { [name: string]: boolean }
+let flags: Flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+
+interface Empty { }
+let empty: Empty;
+empty.nope;
+empty["not allowed either"];

From fe3ed12a20ecc17ed48a99f4c777ebd1f8979ff9 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 5 Dec 2016 09:58:33 -0800
Subject: [PATCH 015/159] Update tests and baselines

---
 tests/baselines/reference/objectRest.js       |  4 ++--
 tests/baselines/reference/objectRest.symbols  |  2 +-
 tests/baselines/reference/objectRest.types    | 10 ++++----
 .../reference/objectRestNegative.errors.txt   |  7 +-----
 .../baselines/reference/objectRestNegative.js |  6 -----
 ...pertyAccessStringIndexSignature.errors.txt | 18 ++++++++++++++
 .../propertyAccessStringIndexSignature.js     | 24 +++++++++++++++++++
 ...ringIndexSignatureNoImplicitAny.errors.txt | 21 ++++++++++++++++
 ...AccessStringIndexSignatureNoImplicitAny.js | 23 ++++++++++++++++++
 .../conformance/types/rest/objectRest.ts      |  2 +-
 .../types/rest/objectRestNegative.ts          |  2 --
 11 files changed, 96 insertions(+), 23 deletions(-)
 create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignature.errors.txt
 create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignature.js
 create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.errors.txt
 create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.js

diff --git a/tests/baselines/reference/objectRest.js b/tests/baselines/reference/objectRest.js
index 48a1bf8daf8..8060098ba4b 100644
--- a/tests/baselines/reference/objectRest.js
+++ b/tests/baselines/reference/objectRest.js
@@ -37,7 +37,7 @@ let computed2 = 'a';
 var { [computed]: stillNotGreat, [computed2]: soSo,  ...o } = o;
 ({ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o);
 
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject['anythingGoes'];
+var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
 
 
 //// [objectRest.js]
@@ -80,6 +80,6 @@ var _g = computed, stillNotGreat = o[_g], _h = computed2, soSo = o[_h], o = __re
 (_j = computed, stillNotGreat = o[_j], _k = computed2, soSo = o[_k], o = __rest(o, [typeof _j === "symbol" ? _j : _j + "", typeof _k === "symbol" ? _k : _k + ""]));
 var noContextualType = (_a) => {
     var { aNumber = 12 } = _a, notEmptyObject = __rest(_a, ["aNumber"]);
-    return aNumber + notEmptyObject['anythingGoes'];
+    return aNumber + notEmptyObject.anythingGoes;
 };
 var _d, _f, _j, _k;
diff --git a/tests/baselines/reference/objectRest.symbols b/tests/baselines/reference/objectRest.symbols
index 46309392135..5bacb33f5da 100644
--- a/tests/baselines/reference/objectRest.symbols
+++ b/tests/baselines/reference/objectRest.symbols
@@ -169,7 +169,7 @@ var { [computed]: stillNotGreat, [computed2]: soSo,  ...o } = o;
 >o : Symbol(o, Decl(objectRest.ts, 0, 3), Decl(objectRest.ts, 35, 51))
 >o : Symbol(o, Decl(objectRest.ts, 0, 3), Decl(objectRest.ts, 35, 51))
 
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject['anythingGoes'];
+var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
 >noContextualType : Symbol(noContextualType, Decl(objectRest.ts, 38, 3))
 >aNumber : Symbol(aNumber, Decl(objectRest.ts, 38, 25))
 >notEmptyObject : Symbol(notEmptyObject, Decl(objectRest.ts, 38, 39))
diff --git a/tests/baselines/reference/objectRest.types b/tests/baselines/reference/objectRest.types
index 1dc05741713..01a85b50348 100644
--- a/tests/baselines/reference/objectRest.types
+++ b/tests/baselines/reference/objectRest.types
@@ -195,15 +195,15 @@ var { [computed]: stillNotGreat, [computed2]: soSo,  ...o } = o;
 >o : { a: number; b: string; }
 >o : { a: number; b: string; }
 
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject['anythingGoes'];
+var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
 >noContextualType : ({aNumber, ...notEmptyObject}: { [x: string]: any; aNumber?: number; }) => any
->({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject['anythingGoes'] : ({aNumber, ...notEmptyObject}: { [x: string]: any; aNumber?: number; }) => any
+>({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes : ({aNumber, ...notEmptyObject}: { [x: string]: any; aNumber?: number; }) => any
 >aNumber : number
 >12 : 12
 >notEmptyObject : { [x: string]: any; }
->aNumber + notEmptyObject['anythingGoes'] : any
+>aNumber + notEmptyObject.anythingGoes : any
 >aNumber : number
->notEmptyObject['anythingGoes'] : any
+>notEmptyObject.anythingGoes : any
 >notEmptyObject : { [x: string]: any; }
->'anythingGoes' : "anythingGoes"
+>anythingGoes : any
 
diff --git a/tests/baselines/reference/objectRestNegative.errors.txt b/tests/baselines/reference/objectRestNegative.errors.txt
index 6e65af4bdc1..56de8aaccb6 100644
--- a/tests/baselines/reference/objectRestNegative.errors.txt
+++ b/tests/baselines/reference/objectRestNegative.errors.txt
@@ -7,10 +7,9 @@ tests/cases/conformance/types/rest/objectRestNegative.ts(11,30): error TS7008: M
 tests/cases/conformance/types/rest/objectRestNegative.ts(11,33): error TS7008: Member 'y' implicitly has an 'any' type.
 tests/cases/conformance/types/rest/objectRestNegative.ts(12,17): error TS2700: Rest types may only be created from object types.
 tests/cases/conformance/types/rest/objectRestNegative.ts(17,9): error TS2701: The target of an object rest assignment must be a variable or a property access.
-tests/cases/conformance/types/rest/objectRestNegative.ts(19,90): error TS2339: Property 'anythingGoes' does not exist on type '{ [x: string]: any; }'.
 
 
-==== tests/cases/conformance/types/rest/objectRestNegative.ts (8 errors) ====
+==== tests/cases/conformance/types/rest/objectRestNegative.ts (7 errors) ====
     let o = { a: 1, b: 'no' };
     var { ...mustBeLast, a } = o;
              ~~~~~~~~~~
@@ -44,8 +43,4 @@ tests/cases/conformance/types/rest/objectRestNegative.ts(19,90): error TS2339: P
     ({a, ...rest.b + rest.b} = o);
             ~~~~~~~~~~~~~~~
 !!! error TS2701: The target of an object rest assignment must be a variable or a property access.
-    
-    var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
-                                                                                             ~~~~~~~~~~~~
-!!! error TS2339: Property 'anythingGoes' does not exist on type '{ [x: string]: any; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/objectRestNegative.js b/tests/baselines/reference/objectRestNegative.js
index 19559e865f2..915e0a0e867 100644
--- a/tests/baselines/reference/objectRestNegative.js
+++ b/tests/baselines/reference/objectRestNegative.js
@@ -16,8 +16,6 @@ function generic<T extends { x, y }>(t: T) {
 
 let rest: { b: string }
 ({a, ...rest.b + rest.b} = o);
-
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
 
 
 //// [objectRestNegative.js]
@@ -44,7 +42,3 @@ function generic(t) {
 }
 var rest;
 (a = o.a, o, rest.b + rest.b = __rest(o, ["a"]));
-var noContextualType = function (_a) {
-    var _b = _a.aNumber, aNumber = _b === void 0 ? 12 : _b, notEmptyObject = __rest(_a, ["aNumber"]);
-    return aNumber + notEmptyObject.anythingGoes;
-};
diff --git a/tests/baselines/reference/propertyAccessStringIndexSignature.errors.txt b/tests/baselines/reference/propertyAccessStringIndexSignature.errors.txt
new file mode 100644
index 00000000000..d376551d91d
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessStringIndexSignature.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts(10,7): error TS2339: Property 'nope' does not exist on type 'Empty'.
+
+
+==== tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignature.ts (1 errors) ====
+    interface Flags { [name: string]: boolean };
+    let flags: Flags;
+    flags.b;
+    flags.f;
+    flags.isNotNecessarilyNeverFalse;
+    flags['this is fine'];
+    
+    interface Empty { }
+    let empty: Empty;
+    empty.nope;
+          ~~~~
+!!! error TS2339: Property 'nope' does not exist on type 'Empty'.
+    empty["that's ok"];
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/propertyAccessStringIndexSignature.js b/tests/baselines/reference/propertyAccessStringIndexSignature.js
new file mode 100644
index 00000000000..d37a8bfea0e
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessStringIndexSignature.js
@@ -0,0 +1,24 @@
+//// [propertyAccessStringIndexSignature.ts]
+interface Flags { [name: string]: boolean };
+let flags: Flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+
+interface Empty { }
+let empty: Empty;
+empty.nope;
+empty["that's ok"];
+
+
+//// [propertyAccessStringIndexSignature.js]
+;
+var flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+var empty;
+empty.nope;
+empty["that's ok"];
diff --git a/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.errors.txt b/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.errors.txt
new file mode 100644
index 00000000000..d5fda181096
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts(10,7): error TS2339: Property 'nope' does not exist on type 'Empty'.
+tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts(11,1): error TS7017: Element implicitly has an 'any' type because type 'Empty' has no index signature.
+
+
+==== tests/cases/conformance/expressions/propertyAccess/propertyAccessStringIndexSignatureNoImplicitAny.ts (2 errors) ====
+    interface Flags { [name: string]: boolean }
+    let flags: Flags;
+    flags.b;
+    flags.f;
+    flags.isNotNecessarilyNeverFalse;
+    flags['this is fine'];
+    
+    interface Empty { }
+    let empty: Empty;
+    empty.nope;
+          ~~~~
+!!! error TS2339: Property 'nope' does not exist on type 'Empty'.
+    empty["not allowed either"];
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS7017: Element implicitly has an 'any' type because type 'Empty' has no index signature.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.js b/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.js
new file mode 100644
index 00000000000..3c2abcc182b
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.js
@@ -0,0 +1,23 @@
+//// [propertyAccessStringIndexSignatureNoImplicitAny.ts]
+interface Flags { [name: string]: boolean }
+let flags: Flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+
+interface Empty { }
+let empty: Empty;
+empty.nope;
+empty["not allowed either"];
+
+
+//// [propertyAccessStringIndexSignatureNoImplicitAny.js]
+var flags;
+flags.b;
+flags.f;
+flags.isNotNecessarilyNeverFalse;
+flags['this is fine'];
+var empty;
+empty.nope;
+empty["not allowed either"];
diff --git a/tests/cases/conformance/types/rest/objectRest.ts b/tests/cases/conformance/types/rest/objectRest.ts
index 2fba5d0b6dc..5891ce2414b 100644
--- a/tests/cases/conformance/types/rest/objectRest.ts
+++ b/tests/cases/conformance/types/rest/objectRest.ts
@@ -37,4 +37,4 @@ let computed2 = 'a';
 var { [computed]: stillNotGreat, [computed2]: soSo,  ...o } = o;
 ({ [computed]: stillNotGreat, [computed2]: soSo, ...o } = o);
 
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject['anythingGoes'];
+var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;
diff --git a/tests/cases/conformance/types/rest/objectRestNegative.ts b/tests/cases/conformance/types/rest/objectRestNegative.ts
index 4f4667fe65a..13d214e453d 100644
--- a/tests/cases/conformance/types/rest/objectRestNegative.ts
+++ b/tests/cases/conformance/types/rest/objectRestNegative.ts
@@ -16,5 +16,3 @@ function generic<T extends { x, y }>(t: T) {
 
 let rest: { b: string }
 ({a, ...rest.b + rest.b} = o);
-
-var noContextualType = ({ aNumber = 12, ...notEmptyObject }) => aNumber + notEmptyObject.anythingGoes;

From 157a9b02fc5e9aa825697bd7779145eded74cdf5 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 5 Dec 2016 08:43:16 -0800
Subject: [PATCH 016/159] Properly determine whether an augmentation is a
 ValueModule or NamespaceModule

---
 src/compiler/binder.ts                        | 19 ++++++++++------
 .../reference/augmentExportEquals7.errors.txt | 22 +++++++++++++++++++
 tests/cases/compiler/augmentExportEquals7.ts  | 10 +++++++++
 3 files changed, 44 insertions(+), 7 deletions(-)
 create mode 100644 tests/baselines/reference/augmentExportEquals7.errors.txt
 create mode 100644 tests/cases/compiler/augmentExportEquals7.ts

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index a6f5993f6c8..e00e9294529 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1509,7 +1509,7 @@ namespace ts {
                     errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
                 }
                 if (isExternalModuleAugmentation(node)) {
-                    declareSymbolAndAddToSymbolTable(node, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);
+                    declareModuleSymbol(node);
                 }
                 else {
                     let pattern: Pattern | undefined;
@@ -1531,12 +1531,8 @@ namespace ts {
                 }
             }
             else {
-                const state = getModuleInstanceState(node);
-                if (state === ModuleInstanceState.NonInstantiated) {
-                    declareSymbolAndAddToSymbolTable(node, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);
-                }
-                else {
-                    declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes);
+                const state = declareModuleSymbol(node);
+                if (state !== ModuleInstanceState.NonInstantiated) {
                     if (node.symbol.flags & (SymbolFlags.Function | SymbolFlags.Class | SymbolFlags.RegularEnum)) {
                         // if module was already merged with some function, class or non-const enum
                         // treat is a non-const-enum-only
@@ -1557,6 +1553,15 @@ namespace ts {
             }
         }
 
+        function declareModuleSymbol(node: ModuleDeclaration): ModuleInstanceState {
+            const state = getModuleInstanceState(node);
+            const instantiated = state !== ModuleInstanceState.NonInstantiated;
+            declareSymbolAndAddToSymbolTable(node,
+                instantiated ? SymbolFlags.ValueModule : SymbolFlags.NamespaceModule,
+                instantiated ? SymbolFlags.ValueModuleExcludes : SymbolFlags.NamespaceModuleExcludes);
+            return state;
+        }
+
         function bindFunctionOrConstructorType(node: SignatureDeclaration): void {
             // For a given function symbol "<...>(...) => T" we want to generate a symbol identical
             // to the one we would get for: { <...>(...): T }
diff --git a/tests/baselines/reference/augmentExportEquals7.errors.txt b/tests/baselines/reference/augmentExportEquals7.errors.txt
new file mode 100644
index 00000000000..1cb9ddc041c
--- /dev/null
+++ b/tests/baselines/reference/augmentExportEquals7.errors.txt
@@ -0,0 +1,22 @@
+/node_modules/@types/lib-extender/index.d.ts(2,16): error TS2300: Duplicate identifier '"lib"'.
+/node_modules/lib/index.d.ts(1,13): error TS2300: Duplicate identifier '"lib"'.
+/node_modules/lib/index.d.ts(2,19): error TS2300: Duplicate identifier '"lib"'.
+
+
+==== /node_modules/lib/index.d.ts (2 errors) ====
+    declare var lib: () => void;
+                ~~~
+!!! error TS2300: Duplicate identifier '"lib"'.
+    declare namespace lib {}
+                      ~~~
+!!! error TS2300: Duplicate identifier '"lib"'.
+    export = lib;
+    
+==== /node_modules/@types/lib-extender/index.d.ts (1 errors) ====
+    import * as lib from "lib";
+    declare module "lib" {
+                   ~~~~~
+!!! error TS2300: Duplicate identifier '"lib"'.
+        export function fn(): void;
+    }
+    
\ No newline at end of file
diff --git a/tests/cases/compiler/augmentExportEquals7.ts b/tests/cases/compiler/augmentExportEquals7.ts
new file mode 100644
index 00000000000..c287bcbe8c4
--- /dev/null
+++ b/tests/cases/compiler/augmentExportEquals7.ts
@@ -0,0 +1,10 @@
+// @Filename: /node_modules/lib/index.d.ts
+declare var lib: () => void;
+declare namespace lib {}
+export = lib;
+
+// @Filename: /node_modules/@types/lib-extender/index.d.ts
+import * as lib from "lib";
+declare module "lib" {
+    export function fn(): void;
+}

From 7beeb77201450aa8a95d494f3fde167c1fb9b550 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 5 Dec 2016 10:58:47 -0800
Subject: [PATCH 017/159] Update baseline

---
 .../reference/globalAugmentationModuleResolution.types          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.types b/tests/baselines/reference/globalAugmentationModuleResolution.types
index c057ea2943d..75f23b0cd6b 100644
--- a/tests/baselines/reference/globalAugmentationModuleResolution.types
+++ b/tests/baselines/reference/globalAugmentationModuleResolution.types
@@ -3,7 +3,7 @@
 export { };
 
 declare global {
->global : any
+>global : typeof global
 
   var x: number;
 >x : number

From 39040f61540c2a2ec3cb9a9cc5c2920a3a0188fe Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 7 Dec 2016 13:13:21 -0800
Subject: [PATCH 018/159] Provide better error message

---
 src/compiler/checker.ts                              |  3 +++
 src/compiler/diagnosticMessages.json                 |  4 ++++
 .../reference/augmentExportEquals7.errors.txt        | 12 +++---------
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 903c8cfda1c..d2d4502c79d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -479,6 +479,9 @@ namespace ts {
                 }
                 recordMergedSymbol(target, source);
             }
+            else if (target.flags & SymbolFlags.NamespaceModule) {
+                error(source.valueDeclaration.name, Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target));
+            }
             else {
                 const message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable
                     ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 4d42c77e566..19b297fd4a9 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1807,6 +1807,10 @@
         "category": "Error",
         "code": 2608
     },
+    "Cannot augment module '{0}' with value exports because it resolves to a non-module entity.": {
+        "category": "Error",
+        "code": 2649
+    },
     "Cannot emit namespaced JSX elements in React": {
         "category": "Error",
         "code": 2650
diff --git a/tests/baselines/reference/augmentExportEquals7.errors.txt b/tests/baselines/reference/augmentExportEquals7.errors.txt
index 1cb9ddc041c..e13cf037023 100644
--- a/tests/baselines/reference/augmentExportEquals7.errors.txt
+++ b/tests/baselines/reference/augmentExportEquals7.errors.txt
@@ -1,22 +1,16 @@
-/node_modules/@types/lib-extender/index.d.ts(2,16): error TS2300: Duplicate identifier '"lib"'.
-/node_modules/lib/index.d.ts(1,13): error TS2300: Duplicate identifier '"lib"'.
-/node_modules/lib/index.d.ts(2,19): error TS2300: Duplicate identifier '"lib"'.
+/node_modules/@types/lib-extender/index.d.ts(2,16): error TS2649: Cannot augment module 'lib' with value exports because it resolves to a non-module entity.
 
 
-==== /node_modules/lib/index.d.ts (2 errors) ====
+==== /node_modules/lib/index.d.ts (0 errors) ====
     declare var lib: () => void;
-                ~~~
-!!! error TS2300: Duplicate identifier '"lib"'.
     declare namespace lib {}
-                      ~~~
-!!! error TS2300: Duplicate identifier '"lib"'.
     export = lib;
     
 ==== /node_modules/@types/lib-extender/index.d.ts (1 errors) ====
     import * as lib from "lib";
     declare module "lib" {
                    ~~~~~
-!!! error TS2300: Duplicate identifier '"lib"'.
+!!! error TS2649: Cannot augment module 'lib' with value exports because it resolves to a non-module entity.
         export function fn(): void;
     }
     
\ No newline at end of file

From 6b1cc8972d3e59f12cbc895e53ce90e76977faff Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 5 Dec 2016 14:13:32 -0800
Subject: [PATCH 019/159] Use native maps when they're available

---
 scripts/processDiagnosticMessages.ts          |  10 +-
 src/compiler/binder.ts                        |  24 +-
 src/compiler/checker.ts                       | 397 +++++++++---------
 src/compiler/commandLineParser.ts             |  75 ++--
 src/compiler/core.ts                          | 327 +++++++++++----
 src/compiler/declarationEmitter.ts            |  12 +-
 src/compiler/emitter.ts                       |  15 +-
 src/compiler/factory.ts                       |  28 +-
 src/compiler/parser.ts                        |   2 +-
 src/compiler/performance.ts                   |  20 +-
 src/compiler/program.ts                       |  44 +-
 src/compiler/scanner.ts                       |  17 +-
 src/compiler/sourcemap.ts                     |   2 +-
 src/compiler/sys.ts                           |  19 +-
 src/compiler/transformer.ts                   |  18 +-
 src/compiler/transformers/es2015.ts           |  17 +-
 src/compiler/transformers/generators.ts       |  24 +-
 src/compiler/transformers/jsx.ts              |   2 +-
 src/compiler/transformers/module/module.ts    |  48 +--
 src/compiler/transformers/module/system.ts    |  48 +--
 src/compiler/transformers/ts.ts               |  14 +-
 src/compiler/tsc.ts                           |  25 +-
 src/compiler/types.ts                         |  20 +-
 src/compiler/utilities.ts                     |  45 +-
 src/compiler/visitor.ts                       |  54 +--
 src/harness/fourslash.ts                      |  28 +-
 src/harness/harness.ts                        |  15 +-
 src/harness/harnessLanguageService.ts         |   4 +-
 src/harness/projectsRunner.ts                 |  21 +-
 .../unittests/cachingInServerLSHost.ts        |  17 +-
 src/harness/unittests/moduleResolution.ts     |  40 +-
 .../unittests/reuseProgramStructure.ts        |   9 +-
 src/harness/unittests/session.ts              |  16 +-
 .../unittests/tsserverProjectSystem.ts        |  38 +-
 src/harness/unittests/typingsInstaller.ts     |   2 +-
 src/server/builder.ts                         |  12 +-
 src/server/client.ts                          |   6 +-
 src/server/editorServices.ts                  |  70 +--
 src/server/lsHost.ts                          |   7 +-
 src/server/project.ts                         |  52 +--
 src/server/scriptInfo.ts                      |   2 +-
 src/server/session.ts                         |   6 +-
 src/server/typingsCache.ts                    |  25 +-
 .../typingsInstaller/typingsInstaller.ts      |  30 +-
 src/server/utilities.ts                       |  21 +-
 src/services/classifier.ts                    |   2 +-
 src/services/codefixes/codeFixProvider.ts     |   8 +-
 src/services/codefixes/importFixes.ts         |  24 +-
 src/services/completions.ts                   |  38 +-
 src/services/documentHighlights.ts            |   4 +-
 src/services/documentRegistry.ts              |   8 +-
 src/services/findAllReferences.ts             |  21 +-
 src/services/formatting/rules.ts              |   2 +-
 src/services/goToDefinition.ts                |   2 +-
 src/services/jsTyping.ts                      |  40 +-
 src/services/navigateTo.ts                    |  18 +-
 src/services/navigationBar.ts                 |  16 +-
 src/services/patternMatcher.ts                |   6 +-
 src/services/services.ts                      |  11 +-
 src/services/signatureHelp.ts                 |   2 +-
 src/services/transpile.ts                     |   4 +-
 .../computedPropertyNames10_ES5.types         |   4 +-
 .../computedPropertyNames10_ES6.types         |   4 +-
 .../computedPropertyNames11_ES5.types         |   4 +-
 .../computedPropertyNames11_ES6.types         |   4 +-
 .../computedPropertyNames4_ES5.types          |   4 +-
 .../computedPropertyNames4_ES6.types          |   4 +-
 ...utedPropertyNamesContextualType6_ES5.types |   2 +-
 ...utedPropertyNamesContextualType6_ES6.types |   2 +-
 ...ntiationAssignmentWithIndexingOnLHS3.types |  16 +-
 ...rConstrainsPropertyDeclarations.errors.txt |   4 +-
 ...ConstrainsPropertyDeclarations2.errors.txt |   4 +-
 .../numericIndexerConstraint5.errors.txt      |   4 +-
 .../objectLiteralIndexerErrors.errors.txt     |   8 +-
 .../reference/objectLiteralIndexers.types     |  10 +-
 ...ctTypeWithStringNamedNumericProperty.types |  30 +-
 ...rConstrainsPropertyDeclarations.errors.txt |   8 +-
 tests/cases/fourslash/fourslash.ts            |  12 +-
 tests/cases/fourslash/localGetReferences.ts   |   5 +-
 tslint.json                                   |   3 +-
 80 files changed, 1117 insertions(+), 949 deletions(-)

diff --git a/scripts/processDiagnosticMessages.ts b/scripts/processDiagnosticMessages.ts
index e5eaa46c8e5..db7a9e0f1f2 100644
--- a/scripts/processDiagnosticMessages.ts
+++ b/scripts/processDiagnosticMessages.ts
@@ -27,7 +27,7 @@ function main(): void {
 
     var inputFilePath = sys.args[0].replace(/\\/g, "/");
     var inputStr = sys.readFile(inputFilePath);
-    
+
     var diagnosticMessages: InputDiagnosticMessageTable = JSON.parse(inputStr);
 
     var names = Utilities.getObjectKeys(diagnosticMessages);
@@ -44,7 +44,7 @@ function main(): void {
 function checkForUniqueCodes(messages: string[], diagnosticTable: InputDiagnosticMessageTable) {
     const originalMessageForCode: string[] = [];
     let numConflicts = 0;
-    
+
     for (const currentMessage of messages) {
         const code = diagnosticTable[currentMessage].code;
 
@@ -74,7 +74,7 @@ function buildUniqueNameMap(names: string[]): ts.Map<string> {
     var uniqueNames = NameGenerator.ensureUniqueness(names, /* isCaseSensitive */ false, /* isFixed */ undefined);
 
     for (var i = 0; i < names.length; i++) {
-        nameMap[names[i]] = uniqueNames[i];
+        nameMap.set(names[i], uniqueNames[i]);
     }
 
     return nameMap;
@@ -91,7 +91,7 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
     for (var i = 0; i < names.length; i++) {
         var name = names[i];
         var diagnosticDetails = messageTable[name];
-        var propName = convertPropertyName(nameMap[name]);
+        var propName = convertPropertyName(nameMap.get(name));
 
         result +=
         '        ' + propName +
@@ -114,7 +114,7 @@ function buildDiagnosticMessageOutput(messageTable: InputDiagnosticMessageTable,
     for (var i = 0; i < names.length; i++) {
         var name = names[i];
         var diagnosticDetails = messageTable[name];
-        var propName = convertPropertyName(nameMap[name]);
+        var propName = convertPropertyName(nameMap.get(name));
 
         result += '\r\n  "' + createKey(propName, diagnosticDetails.code) + '"' + ' : "' + name.replace(/[\"]/g, '\\"') + '"';
         if (i !== names.length - 1) {
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index a6f5993f6c8..18a6d00e922 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -349,17 +349,17 @@ namespace ts {
                 // Otherwise, we'll be merging into a compatible existing symbol (for example when
                 // you have multiple 'vars' with the same name in the same container).  In this case
                 // just add this node into the declarations list of the symbol.
-                symbol = symbolTable[name] || (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+                symbol = symbolTable.get(name) || set(symbolTable, name, createSymbol(SymbolFlags.None, name));
 
                 if (name && (includes & SymbolFlags.Classifiable)) {
-                    classifiableNames[name] = name;
+                    classifiableNames.set(name, name);
                 }
 
                 if (symbol.flags & excludes) {
                     if (symbol.isReplaceableByMethod) {
                         // Javascript constructor-declared symbols can be discarded in favor of
                         // prototype symbols like methods.
-                        symbol = symbolTable[name] = createSymbol(SymbolFlags.None, name);
+                        symbol = set(symbolTable, name, createSymbol(SymbolFlags.None, name));
                     }
                     else {
                         if (node.name) {
@@ -1570,7 +1570,7 @@ namespace ts {
             const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
             addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
             typeLiteralSymbol.members = createMap<Symbol>();
-            typeLiteralSymbol.members[symbol.name] = symbol;
+            typeLiteralSymbol.members.set(symbol.name, symbol);
         }
 
         function bindObjectLiteralExpression(node: ObjectLiteralExpression) {
@@ -1601,9 +1601,9 @@ namespace ts {
                         ? ElementKind.Property
                         : ElementKind.Accessor;
 
-                    const existingKind = seen[identifier.text];
+                    const existingKind = seen.get(identifier.text);
                     if (!existingKind) {
-                        seen[identifier.text] = currentKind;
+                        seen.set(identifier.text, currentKind);
                         continue;
                     }
 
@@ -2208,7 +2208,7 @@ namespace ts {
             constructorFunction.parent = classPrototype;
             classPrototype.parent = leftSideOfAssignment;
 
-            const funcSymbol = container.locals[constructorFunction.text];
+            const funcSymbol = container.locals.get(constructorFunction.text);
             if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) {
                 return;
             }
@@ -2239,7 +2239,7 @@ namespace ts {
                 bindAnonymousDeclaration(node, SymbolFlags.Class, bindingName);
                 // Add name of class expression into the map for semantic classifier
                 if (node.name) {
-                    classifiableNames[node.name.text] = node.name.text;
+                    classifiableNames.set(node.name.text, node.name.text);
                 }
             }
 
@@ -2255,14 +2255,14 @@ namespace ts {
             // module might have an exported variable called 'prototype'.  We can't allow that as
             // that would clash with the built-in 'prototype' for the class.
             const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
-            if (symbol.exports[prototypeSymbol.name]) {
+            const symbolExport = symbol.exports.get(prototypeSymbol.name);
+            if (symbolExport) {
                 if (node.name) {
                     node.name.parent = node;
                 }
-                file.bindDiagnostics.push(createDiagnosticForNode(symbol.exports[prototypeSymbol.name].declarations[0],
-                    Diagnostics.Duplicate_identifier_0, prototypeSymbol.name));
+                file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], Diagnostics.Duplicate_identifier_0, prototypeSymbol.name));
             }
-            symbol.exports[prototypeSymbol.name] = prototypeSymbol;
+            symbol.exports.set(prototypeSymbol.name, prototypeSymbol);
             prototypeSymbol.parent = symbol;
         }
 
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index dc97d347e95..00a6ad2c366 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -371,7 +371,7 @@ namespace ts {
         }
 
         const builtinGlobals = createMap<Symbol>();
-        builtinGlobals[undefinedSymbol.name] = undefinedSymbol;
+        builtinGlobals.set(undefinedSymbol.name, undefinedSymbol);
 
         initializeTypeChecker();
 
@@ -492,18 +492,19 @@ namespace ts {
         }
 
         function mergeSymbolTable(target: SymbolTable, source: SymbolTable) {
-            for (const id in source) {
-                let targetSymbol = target[id];
+            source.forEach((sourceSymbol, id) => {
+                let targetSymbol = target.get(id);
                 if (!targetSymbol) {
-                    target[id] = source[id];
+                    target.set(id, sourceSymbol);
                 }
                 else {
                     if (!(targetSymbol.flags & SymbolFlags.Merged)) {
-                        target[id] = targetSymbol = cloneSymbol(targetSymbol);
+                        targetSymbol = cloneSymbol(targetSymbol);
+                        target.set(id, targetSymbol);
                     }
-                    mergeSymbol(targetSymbol, source[id]);
+                    mergeSymbol(targetSymbol, sourceSymbol);
                 }
-            }
+            });
         }
 
         function mergeModuleAugmentation(moduleName: LiteralExpression): void {
@@ -544,15 +545,16 @@ namespace ts {
         }
 
         function addToSymbolTable(target: SymbolTable, source: SymbolTable, message: DiagnosticMessage) {
-            for (const id in source) {
-                if (target[id]) {
+            source.forEach((sourceSymbol, id) => {
+                const targetSymbol = target.get(id);
+                if (targetSymbol) {
                     // Error on redeclarations
-                    forEach(target[id].declarations, addDeclarationDiagnostic(id, message));
+                    forEach(targetSymbol.declarations, addDeclarationDiagnostic(id, message));
                 }
                 else {
-                    target[id] = source[id];
+                    target.set(id, sourceSymbol);
                 }
-            }
+            });
 
             function addDeclarationDiagnostic(id: string, message: DiagnosticMessage) {
                 return (declaration: Declaration) => diagnostics.add(createDiagnosticForNode(declaration, message, id));
@@ -580,7 +582,7 @@ namespace ts {
 
         function getSymbol(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol {
             if (meaning) {
-                const symbol = symbols[name];
+                const symbol = symbols.get(name);
                 if (symbol) {
                     Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
                     if (symbol.flags & meaning) {
@@ -765,7 +767,7 @@ namespace ts {
 
                             // It's an external module. First see if the module has an export default and if the local
                             // name of that export default matches.
-                            if (result = moduleExports["default"]) {
+                            if (result = moduleExports.get("default")) {
                                 const localSymbol = getLocalSymbolForExportDefault(result);
                                 if (localSymbol && (result.flags & meaning) && localSymbol.name === name) {
                                     break loop;
@@ -784,9 +786,10 @@ namespace ts {
                             //     2. We check === SymbolFlags.Alias in order to check that the symbol is *purely*
                             //        an alias. If we used &, we'd be throwing out symbols that have non alias aspects,
                             //        which is not the desired behavior.
-                            if (moduleExports[name] &&
-                                moduleExports[name].flags === SymbolFlags.Alias &&
-                                getDeclarationOfKind(moduleExports[name], SyntaxKind.ExportSpecifier)) {
+                            const moduleExport = moduleExports.get(name);
+                            if (moduleExport &&
+                                moduleExport.flags === SymbolFlags.Alias &&
+                                getDeclarationOfKind(moduleExport, SyntaxKind.ExportSpecifier)) {
                                 break;
                             }
                         }
@@ -1114,11 +1117,16 @@ namespace ts {
             const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
 
             if (moduleSymbol) {
-                const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol) ?
-                    moduleSymbol :
-                    moduleSymbol.exports["export="] ?
-                        getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") :
-                        resolveSymbol(moduleSymbol.exports["default"]);
+                let exportDefaultSymbol: Symbol;
+                if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
+                    exportDefaultSymbol = moduleSymbol;
+                }
+                else {
+                    const exportValue = moduleSymbol.exports.get("export=");
+                    exportDefaultSymbol = exportValue
+                        ? getPropertyOfType(getTypeOfSymbol(exportValue), "default")
+                        : resolveSymbol(moduleSymbol.exports.get("default"));
+                }
 
                 if (!exportDefaultSymbol && !allowSyntheticDefaultImports) {
                     error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
@@ -1168,7 +1176,7 @@ namespace ts {
 
         function getExportOfModule(symbol: Symbol, name: string): Symbol {
             if (symbol.flags & SymbolFlags.Module) {
-                const exportedSymbol = getExportsOfSymbol(symbol)[name];
+                const exportedSymbol = getExportsOfSymbol(symbol).get(name);
                 if (exportedSymbol) {
                     return resolveSymbol(exportedSymbol);
                 }
@@ -1196,7 +1204,7 @@ namespace ts {
 
                     let symbolFromVariable: Symbol;
                     // First check if module was specified with "export=". If so, get the member from the resolved type
-                    if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports["export="]) {
+                    if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=")) {
                         symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.text);
                     }
                     else {
@@ -1475,7 +1483,7 @@ namespace ts {
         // An external module with an 'export =' declaration resolves to the target of the 'export =' declaration,
         // and an external module with no 'export =' declaration resolves to the module itself.
         function resolveExternalModuleSymbol(moduleSymbol: Symbol): Symbol {
-            return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports["export="])) || moduleSymbol;
+            return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports.get("export="))) || moduleSymbol;
         }
 
         // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export ='
@@ -1491,7 +1499,7 @@ namespace ts {
         }
 
         function hasExportAssignmentSymbol(moduleSymbol: Symbol): boolean {
-            return moduleSymbol.exports["export="] !== undefined;
+            return moduleSymbol.exports.get("export=") !== undefined;
         }
 
         function getExportsOfModuleAsArray(moduleSymbol: Symbol): Symbol[] {
@@ -1501,7 +1509,7 @@ namespace ts {
         function tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined {
             const symbolTable = getExportsOfModule(moduleSymbol);
             if (symbolTable) {
-                return symbolTable[memberName];
+                return symbolTable.get(memberName);
             }
         }
 
@@ -1524,24 +1532,30 @@ namespace ts {
          * Not passing `lookupTable` and `exportNode` disables this collection, and just extends the tables
          */
         function extendExportSymbols(target: SymbolTable, source: SymbolTable, lookupTable?: Map<ExportCollisionTracker>, exportNode?: ExportDeclaration) {
-            for (const id in source) {
-                if (id !== "default" && !target[id]) {
-                    target[id] = source[id];
+            if (!source) return;
+
+            source.forEach((sourceSymbol, id) => {
+                if (id === "default") return;
+
+                const targetSymbol = target.get(id);
+                if (!targetSymbol) {
+                    target.set(id, sourceSymbol);
                     if (lookupTable && exportNode) {
-                        lookupTable[id] = {
+                        lookupTable.set(id, {
                             specifierText: getTextOfNode(exportNode.moduleSpecifier)
-                        } as ExportCollisionTracker;
+                        } as ExportCollisionTracker);
                     }
                 }
-                else if (lookupTable && exportNode && id !== "default" && target[id] && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
-                    if (!lookupTable[id].exportsWithDuplicate) {
-                        lookupTable[id].exportsWithDuplicate = [exportNode];
+                else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) {
+                    const collisionTracker = lookupTable.get(id);
+                    if (!collisionTracker.exportsWithDuplicate) {
+                        collisionTracker.exportsWithDuplicate = [exportNode];
                     }
                     else {
-                        lookupTable[id].exportsWithDuplicate.push(exportNode);
+                        collisionTracker.exportsWithDuplicate.push(exportNode);
                     }
                 }
-            }
+            });
         }
 
         function getExportsForModule(moduleSymbol: Symbol): SymbolTable {
@@ -1561,7 +1575,7 @@ namespace ts {
                 visitedSymbols.push(symbol);
                 const symbols = cloneMap(symbol.exports);
                 // All export * declarations are collected in an __export symbol by the binder
-                const exportStars = symbol.exports["__export"];
+                const exportStars = symbol.exports.get("__export");
                 if (exportStars) {
                     const nestedSymbols = createMap<Symbol>();
                     const lookupTable = createMap<ExportCollisionTracker>();
@@ -1575,21 +1589,20 @@ namespace ts {
                             node as ExportDeclaration
                         );
                     }
-                    for (const id in lookupTable) {
-                        const { exportsWithDuplicate } = lookupTable[id];
+                    lookupTable.forEach(({ exportsWithDuplicate }, id) => {
                         // It's not an error if the file with multiple `export *`s with duplicate names exports a member with that name itself
-                        if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols[id]) {
-                            continue;
+                        if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) {
+                            return;
                         }
                         for (const node of exportsWithDuplicate) {
                             diagnostics.add(createDiagnosticForNode(
                                 node,
                                 Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity,
-                                lookupTable[id].specifierText,
+                                lookupTable.get(id).specifierText,
                                 id
                             ));
                         }
-                    }
+                    });
                     extendExportSymbols(symbols, nestedSymbols);
                 }
                 return symbols;
@@ -1684,15 +1697,14 @@ namespace ts {
 
         function getNamedMembers(members: SymbolTable): Symbol[] {
             let result: Symbol[];
-            for (const id in members) {
+            members.forEach((symbol, id) => {
                 if (!isReservedMemberName(id)) {
                     if (!result) result = [];
-                    const symbol = members[id];
                     if (symbolIsValue(symbol)) {
                         result.push(symbol);
                     }
                 }
-            }
+            });
             return result || emptyArray;
         }
 
@@ -1765,12 +1777,12 @@ namespace ts {
                 }
 
                 // If symbol is directly available by its name in the symbol table
-                if (isAccessible(symbols[symbol.name])) {
+                if (isAccessible(symbols.get(symbol.name))) {
                     return [symbol];
                 }
 
                 // Check if symbol is any of the alias
-                return forEachProperty(symbols, symbolFromSymbolTable => {
+                return forEachInMap(symbols, symbolFromSymbolTable => {
                     if (symbolFromSymbolTable.flags & SymbolFlags.Alias
                         && symbolFromSymbolTable.name !== "export="
                         && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) {
@@ -1805,7 +1817,7 @@ namespace ts {
             let qualify = false;
             forEachSymbolTableInScope(enclosingDeclaration, symbolTable => {
                 // If symbol of this name is not available in the symbol table we are ok
-                let symbolFromSymbolTable = symbolTable[symbol.name];
+                let symbolFromSymbolTable = symbolTable.get(symbol.name);
                 if (!symbolFromSymbolTable) {
                     // Continue to the next symbol table
                     return false;
@@ -3068,15 +3080,15 @@ namespace ts {
             const members = createMap<Symbol>();
             const names = createMap<true>();
             for (const name of properties) {
-                names[getTextOfPropertyName(name)] = true;
+                names.set(getTextOfPropertyName(name), true);
             }
             for (const prop of getPropertiesOfType(source)) {
-                const inNamesToRemove = prop.name in names;
+                const inNamesToRemove = names.has(prop.name);
                 const isPrivate = getDeclarationModifierFlagsFromSymbol(prop) & (ModifierFlags.Private | ModifierFlags.Protected);
                 const isMethod = prop.flags & SymbolFlags.Method;
                 const isSetOnlyAccessor = prop.flags & SymbolFlags.SetAccessor && !(prop.flags & SymbolFlags.GetAccessor);
                 if (!inNamesToRemove && !isPrivate && !isMethod && !isSetOnlyAccessor) {
-                    members[prop.name] = prop;
+                    members.set(prop.name, prop);
                 }
             }
             const stringIndexInfo = getIndexInfoOfType(source, IndexKind.String);
@@ -3338,7 +3350,7 @@ namespace ts {
                 const symbol = <TransientSymbol>createSymbol(flags, text);
                 symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
                 symbol.bindingElement = e;
-                members[symbol.name] = symbol;
+                members.set(symbol.name, symbol);
             });
             const result = createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, undefined);
             if (includePatternInType) {
@@ -3939,7 +3951,7 @@ namespace ts {
                     type.outerTypeParameters = outerTypeParameters;
                     type.localTypeParameters = localTypeParameters;
                     (<GenericType>type).instantiations = createMap<TypeReference>();
-                    (<GenericType>type).instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
+                    (<GenericType>type).instantiations.set(getTypeListId(type.typeParameters), <GenericType>type);
                     (<GenericType>type).target = <GenericType>type;
                     (<GenericType>type).typeArguments = type.typeParameters;
                     type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter);
@@ -3982,7 +3994,7 @@ namespace ts {
                         // an instantiation of the type alias with the type parameters supplied as type arguments.
                         links.typeParameters = typeParameters;
                         links.instantiations = createMap<Type>();
-                        links.instantiations[getTypeListId(typeParameters)] = type;
+                        links.instantiations.set(getTypeListId(typeParameters), type);
                     }
                 }
                 else {
@@ -4002,7 +4014,7 @@ namespace ts {
             return expr.kind === SyntaxKind.NumericLiteral ||
                 expr.kind === SyntaxKind.PrefixUnaryExpression && (<PrefixUnaryExpression>expr).operator === SyntaxKind.MinusToken &&
                 (<PrefixUnaryExpression>expr).operand.kind === SyntaxKind.NumericLiteral ||
-                expr.kind === SyntaxKind.Identifier && !!symbol.exports[(<Identifier>expr).text];
+                expr.kind === SyntaxKind.Identifier && !!symbol.exports.get((<Identifier>expr).text);
         }
 
         function enumHasLiteralMembers(symbol: Symbol) {
@@ -4040,8 +4052,8 @@ namespace ts {
                             for (const member of (<EnumDeclaration>declaration).members) {
                                 const memberSymbol = getSymbolOfNode(member);
                                 const value = getEnumMemberValue(member);
-                                if (!memberTypes[value]) {
-                                    const memberType = memberTypes[value] = createEnumLiteralType(memberSymbol, enumType, "" + value);
+                                if (!memberTypes.has(value)) {
+                                    const memberType = set(memberTypes, value, createEnumLiteralType(memberSymbol, enumType, "" + value));
                                     memberTypeList.push(memberType);
                                 }
                             }
@@ -4051,7 +4063,7 @@ namespace ts {
                     if (memberTypeList.length > 1) {
                         enumType.flags |= TypeFlags.Union;
                         (<EnumType & UnionType>enumType).types = memberTypeList;
-                        unionTypes[getTypeListId(memberTypeList)] = <EnumType & UnionType>enumType;
+                        unionTypes.set(getTypeListId(memberTypeList), <EnumType & UnionType>enumType);
                     }
                 }
             }
@@ -4063,7 +4075,7 @@ namespace ts {
             if (!links.declaredType) {
                 const enumType = <EnumType>getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
                 links.declaredType = enumType.flags & TypeFlags.Union ?
-                    enumType.memberTypes[getEnumMemberValue(<EnumMember>symbol.valueDeclaration)] :
+                    enumType.memberTypes.get(getEnumMemberValue(<EnumMember>symbol.valueDeclaration)) :
                     enumType;
             }
             return links.declaredType;
@@ -4195,7 +4207,7 @@ namespace ts {
         function createSymbolTable(symbols: Symbol[]): SymbolTable {
             const result = createMap<Symbol>();
             for (const symbol of symbols) {
-                result[symbol.name] = symbol;
+                result.set(symbol.name, symbol);
             }
             return result;
         }
@@ -4205,15 +4217,15 @@ namespace ts {
         function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper, mappingThisOnly: boolean): SymbolTable {
             const result = createMap<Symbol>();
             for (const symbol of symbols) {
-                result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
+                result.set(symbol.name, mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper));
             }
             return result;
         }
 
         function addInheritedMembers(symbols: SymbolTable, baseSymbols: Symbol[]) {
             for (const s of baseSymbols) {
-                if (!symbols[s.name]) {
-                    symbols[s.name] = s;
+                if (!symbols.has(s.name)) {
+                    symbols.set(s.name, s);
                 }
             }
         }
@@ -4222,8 +4234,8 @@ namespace ts {
             if (!(<InterfaceTypeWithDeclaredMembers>type).declaredProperties) {
                 const symbol = type.symbol;
                 (<InterfaceTypeWithDeclaredMembers>type).declaredProperties = getNamedMembers(symbol.members);
-                (<InterfaceTypeWithDeclaredMembers>type).declaredCallSignatures = getSignaturesOfSymbol(symbol.members["__call"]);
-                (<InterfaceTypeWithDeclaredMembers>type).declaredConstructSignatures = getSignaturesOfSymbol(symbol.members["__new"]);
+                (<InterfaceTypeWithDeclaredMembers>type).declaredCallSignatures = getSignaturesOfSymbol(symbol.members.get("__call"));
+                (<InterfaceTypeWithDeclaredMembers>type).declaredConstructSignatures = getSignaturesOfSymbol(symbol.members.get("__new"));
                 (<InterfaceTypeWithDeclaredMembers>type).declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.String);
                 (<InterfaceTypeWithDeclaredMembers>type).declaredNumberIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.Number);
             }
@@ -4468,8 +4480,8 @@ namespace ts {
             }
             else if (symbol.flags & SymbolFlags.TypeLiteral) {
                 const members = symbol.members;
-                const callSignatures = getSignaturesOfSymbol(members["__call"]);
-                const constructSignatures = getSignaturesOfSymbol(members["__new"]);
+                const callSignatures = getSignaturesOfSymbol(members.get("__call"));
+                const constructSignatures = getSignaturesOfSymbol(members.get("__new"));
                 const stringIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.String);
                 const numberIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.Number);
                 setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo);
@@ -4483,7 +4495,7 @@ namespace ts {
                 }
                 if (symbol.flags & SymbolFlags.Class) {
                     const classType = getDeclaredTypeOfClassOrInterface(symbol);
-                    constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]);
+                    constructSignatures = getSignaturesOfSymbol(symbol.members.get("__constructor"));
                     if (!constructSignatures.length) {
                         constructSignatures = getDefaultConstructSignatures(classType);
                     }
@@ -4541,7 +4553,7 @@ namespace ts {
                     const prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | (isOptional ? SymbolFlags.Optional : 0), propName);
                     prop.type = propType;
                     prop.isReadonly = templateReadonly || homomorphicProp && isReadonlySymbol(homomorphicProp);
-                    members[propName] = prop;
+                    members.set(propName, prop);
                 }
                 else if (t.flags & TypeFlags.String) {
                     stringIndexInfo = createIndexInfo(propType, templateReadonly);
@@ -4623,7 +4635,7 @@ namespace ts {
         function getPropertyOfObjectType(type: Type, name: string): Symbol {
             if (type.flags & TypeFlags.Object) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                const symbol = resolved.members[name];
+                const symbol = resolved.members.get(name);
                 if (symbol && symbolIsValue(symbol)) {
                     return symbol;
                 }
@@ -4644,13 +4656,12 @@ namespace ts {
             const props = type.resolvedProperties;
             if (props) {
                 const result: Symbol[] = [];
-                for (const key in props) {
-                    const prop = props[key];
+                props.forEach(prop => {
                     // We need to filter out partial properties in union types
                     if (!(prop.flags & SymbolFlags.SyntheticProperty && (<TransientSymbol>prop).isPartial)) {
                         result.push(prop);
                     }
-                }
+                });
                 return result;
             }
             return emptyArray;
@@ -4770,11 +4781,11 @@ namespace ts {
         // and do not appear to be present in the union type.
         function getUnionOrIntersectionProperty(type: UnionOrIntersectionType, name: string): Symbol {
             const properties = type.resolvedProperties || (type.resolvedProperties = createMap<Symbol>());
-            let property = properties[name];
+            let property = properties.get(name);
             if (!property) {
                 property = createUnionOrIntersectionProperty(type, name);
                 if (property) {
-                    properties[name] = property;
+                    properties.set(name, property);
                 }
             }
             return property;
@@ -4798,7 +4809,7 @@ namespace ts {
             type = getApparentType(type);
             if (type.flags & TypeFlags.Object) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                const symbol = resolved.members[name];
+                const symbol = resolved.members.get(name);
                 if (symbol && symbolIsValue(symbol)) {
                     return symbol;
                 }
@@ -4897,11 +4908,11 @@ namespace ts {
 
         function symbolsToArray(symbols: SymbolTable): Symbol[] {
             const result: Symbol[] = [];
-            for (const id in symbols) {
+            symbols.forEach((symbol, id) => {
                 if (!isReservedMemberName(id)) {
-                    result.push(symbols[id]);
+                    result.push(symbol);
                 }
-            }
+            });
             return result;
         }
 
@@ -5175,7 +5186,7 @@ namespace ts {
         function getSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
             const instantiations = signature.instantiations || (signature.instantiations = createMap<Signature>());
             const id = getTypeListId(typeArguments);
-            return instantiations[id] || (instantiations[id] = createSignatureInstantiation(signature, typeArguments));
+            return instantiations.get(id) || set(instantiations, id, createSignatureInstantiation(signature, typeArguments));
         }
 
         function createSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
@@ -5209,7 +5220,7 @@ namespace ts {
         }
 
         function getIndexSymbol(symbol: Symbol): Symbol {
-            return symbol.members["__index"];
+            return symbol.members.get("__index");
         }
 
         function getIndexDeclarationOfSymbol(symbol: Symbol, kind: IndexKind): SignatureDeclaration {
@@ -5323,9 +5334,9 @@ namespace ts {
 
         function createTypeReference(target: GenericType, typeArguments: Type[]): TypeReference {
             const id = getTypeListId(typeArguments);
-            let type = target.instantiations[id];
+            let type = target.instantiations.get(id);
             if (!type) {
-                type = target.instantiations[id] = <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol);
+                type = set(target.instantiations, id, <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol));
                 type.flags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
                 type.target = target;
                 type.typeArguments = typeArguments;
@@ -5372,7 +5383,7 @@ namespace ts {
             const links = getSymbolLinks(symbol);
             const typeParameters = links.typeParameters;
             const id = getTypeListId(typeArguments);
-            return links.instantiations[id] || (links.instantiations[id] = instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
+            return links.instantiations.get(id) || set(links.instantiations, id, instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
         }
 
         // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include
@@ -5613,7 +5624,7 @@ namespace ts {
             type.outerTypeParameters = undefined;
             type.localTypeParameters = typeParameters;
             type.instantiations = createMap<TypeReference>();
-            type.instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
+            type.instantiations.set(getTypeListId(type.typeParameters), <GenericType>type);
             type.target = <GenericType>type;
             type.typeArguments = type.typeParameters;
             type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter);
@@ -5818,10 +5829,10 @@ namespace ts {
                 return types[0];
             }
             const id = getTypeListId(types);
-            let type = unionTypes[id];
+            let type = unionTypes.get(id);
             if (!type) {
                 const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
-                type = unionTypes[id] = <UnionType>createType(TypeFlags.Union | propagatedFlags);
+                type = set(unionTypes, id, <UnionType>createType(TypeFlags.Union | propagatedFlags));
                 type.types = types;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
@@ -5892,10 +5903,10 @@ namespace ts {
                     /*subtypeReduction*/ false, aliasSymbol, aliasTypeArguments);
             }
             const id = getTypeListId(typeSet);
-            let type = intersectionTypes[id];
+            let type = intersectionTypes.get(id);
             if (!type) {
                 const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
-                type = intersectionTypes[id] = <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags);
+                type = set(intersectionTypes, id, <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags));
                 type.types = typeSet;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
@@ -6054,7 +6065,7 @@ namespace ts {
                 }
                 // Otherwise we defer the operation by creating an indexed access type.
                 const id = objectType.id + "," + indexType.id;
-                return indexedAccessTypes[id] || (indexedAccessTypes[id] = createIndexedAccessType(objectType, indexType));
+                return indexedAccessTypes.get(id) || set(indexedAccessTypes, id, createIndexedAccessType(objectType, indexType));
             }
             const apparentObjectType = getApparentType(objectType);
             if (indexType.flags & TypeFlags.Union && !(indexType.flags & TypeFlags.Primitive)) {
@@ -6099,7 +6110,7 @@ namespace ts {
             if (!links.resolvedType) {
                 // Deferred resolution of members is handled by resolveObjectTypeMembers
                 const aliasSymbol = getAliasSymbolForTypeNode(node);
-                if (isEmpty(node.symbol.members) && !aliasSymbol) {
+                if (mapIsEmpty(node.symbol.members) && !aliasSymbol) {
                     links.resolvedType = emptyTypeLiteralType;
                 }
                 else {
@@ -6164,19 +6175,19 @@ namespace ts {
                 const isOwnProperty = !(rightProp.flags & SymbolFlags.Method) || isFromObjectLiteral;
                 const isSetterWithoutGetter = rightProp.flags & SymbolFlags.SetAccessor && !(rightProp.flags & SymbolFlags.GetAccessor);
                 if (getDeclarationModifierFlagsFromSymbol(rightProp) & (ModifierFlags.Private | ModifierFlags.Protected)) {
-                    skippedPrivateMembers[rightProp.name] = true;
+                    skippedPrivateMembers.set(rightProp.name, true);
                 }
                 else if (isOwnProperty && !isSetterWithoutGetter) {
-                    members[rightProp.name] = rightProp;
+                    members.set(rightProp.name, rightProp);
                 }
             }
             for (const leftProp of getPropertiesOfType(left)) {
                 if (leftProp.flags & SymbolFlags.SetAccessor && !(leftProp.flags & SymbolFlags.GetAccessor)
-                    || leftProp.name in skippedPrivateMembers) {
+                    || skippedPrivateMembers.has(leftProp.name)) {
                     continue;
                 }
-                if (leftProp.name in members) {
-                    const rightProp = members[leftProp.name];
+                if (members.has(leftProp.name)) {
+                    const rightProp = members.get(leftProp.name);
                     const rightType = getTypeOfSymbol(rightProp);
                     if (maybeTypeOfKind(rightType, TypeFlags.Undefined) || rightProp.flags & SymbolFlags.Optional) {
                         const declarations: Declaration[] = concatenate(leftProp.declarations, rightProp.declarations);
@@ -6187,11 +6198,11 @@ namespace ts {
                         result.rightSpread = rightProp;
                         result.declarations = declarations;
                         result.isReadonly = isReadonlySymbol(leftProp) || isReadonlySymbol(rightProp);
-                        members[leftProp.name] = result;
+                        members.set(leftProp.name, result);
                     }
                 }
                 else {
-                    members[leftProp.name] = leftProp;
+                    members.set(leftProp.name, leftProp);
                 }
             }
             return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
@@ -6221,7 +6232,7 @@ namespace ts {
 
         function getLiteralTypeForText(flags: TypeFlags, text: string) {
             const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes;
-            return map[text] || (map[text] = createLiteralType(flags, text));
+            return map.get(text) || set(map, text, createLiteralType(flags, text));
         }
 
         function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
@@ -7006,13 +7017,14 @@ namespace ts {
                 return true;
             }
             const id = source.id + "," + target.id;
-            if (enumRelation[id] !== undefined) {
-                return enumRelation[id];
+            const relation = enumRelation.get(id);
+            if (relation !== undefined) {
+                return relation;
             }
             if (source.symbol.name !== target.symbol.name ||
                 !(source.symbol.flags & SymbolFlags.RegularEnum) || !(target.symbol.flags & SymbolFlags.RegularEnum) ||
                 (source.flags & TypeFlags.Union) !== (target.flags & TypeFlags.Union)) {
-                return enumRelation[id] = false;
+                return set(enumRelation, id, false);
             }
             const targetEnumType = getTypeOfSymbol(target.symbol);
             for (const property of getPropertiesOfType(getTypeOfSymbol(source.symbol))) {
@@ -7023,11 +7035,11 @@ namespace ts {
                             errorReporter(Diagnostics.Property_0_is_missing_in_type_1, property.name,
                                 typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
                         }
-                        return enumRelation[id] = false;
+                        return set(enumRelation, id, false);
                     }
                 }
             }
-            return enumRelation[id] = true;
+            return set(enumRelation, id, true);
         }
 
         function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
@@ -7070,7 +7082,7 @@ namespace ts {
             }
             if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {
                 const id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
-                const related = relation[id];
+                const related = relation.get(id);
                 if (related !== undefined) {
                     return related === RelationComparisonResult.Succeeded;
                 }
@@ -7527,12 +7539,12 @@ namespace ts {
                     return Ternary.False;
                 }
                 const id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
-                const related = relation[id];
+                const related = relation.get(id);
                 if (related !== undefined) {
                     if (reportErrors && related === RelationComparisonResult.Failed) {
                         // We are elaborating errors and the cached result is an unreported failure. Record the result as a reported
                         // failure and continue computing the relation such that errors get reported.
-                        relation[id] = RelationComparisonResult.FailedAndReported;
+                        relation.set(id, RelationComparisonResult.FailedAndReported);
                     }
                     else {
                         return related === RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
@@ -7541,7 +7553,7 @@ namespace ts {
                 if (depth > 0) {
                     for (let i = 0; i < depth; i++) {
                         // If source and target are already being compared, consider them related with assumptions
-                        if (maybeStack[i][id]) {
+                        if (maybeStack[i].get(id)) {
                             return Ternary.Maybe;
                         }
                     }
@@ -7559,7 +7571,7 @@ namespace ts {
                 sourceStack[depth] = source;
                 targetStack[depth] = target;
                 maybeStack[depth] = createMap<RelationComparisonResult>();
-                maybeStack[depth][id] = RelationComparisonResult.Succeeded;
+                maybeStack[depth].set(id, RelationComparisonResult.Succeeded);
                 depth++;
                 const saveExpandingFlags = expandingFlags;
                 if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1;
@@ -7592,12 +7604,12 @@ namespace ts {
                     const maybeCache = maybeStack[depth];
                     // If result is definitely true, copy assumptions to global cache, else copy to next level up
                     const destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
-                    copyProperties(maybeCache, destinationCache);
+                    copyMapEntries(maybeCache, destinationCache);
                 }
                 else {
                     // A false result goes straight into global cache (when something is false under assumptions it
                     // will also be false without assumptions)
-                    relation[id] = reportErrors ? RelationComparisonResult.FailedAndReported : RelationComparisonResult.Failed;
+                    relation.set(id, reportErrors ? RelationComparisonResult.FailedAndReported : RelationComparisonResult.Failed);
                 }
                 return result;
             }
@@ -8266,7 +8278,7 @@ namespace ts {
             for (const property of getPropertiesOfObjectType(type)) {
                 const original = getTypeOfSymbol(property);
                 const updated = f(original);
-                members[property.name] = updated === original ? property : createTransientSymbol(property, updated);
+                members.set(property.name, updated === original ? property : createTransientSymbol(property, updated));
             };
             return members;
         }
@@ -8508,7 +8520,7 @@ namespace ts {
                 inferredProp.declarations = prop.declarations;
                 inferredProp.type = inferredPropType;
                 inferredProp.isReadonly = readonlyMask && isReadonlySymbol(prop);
-                members[prop.name] = inferredProp;
+                members.set(prop.name, inferredProp);
             }
             if (indexInfo) {
                 const inferredIndexType = inferTargetType(indexInfo.type);
@@ -8683,10 +8695,10 @@ namespace ts {
                             return;
                         }
                         const key = source.id + "," + target.id;
-                        if (visited[key]) {
+                        if (visited.get(key)) {
                             return;
                         }
-                        visited[key] = true;
+                        visited.set(key, true);
                         if (depth === 0) {
                             sourceStack = [];
                             targetStack = [];
@@ -9067,7 +9079,7 @@ namespace ts {
             // check. This gives us a quicker out in the common case where an object type is not a function.
             const resolved = resolveStructuredTypeMembers(type);
             return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
-                resolved.members["bind"] && isTypeSubtypeOf(type, globalFunctionType));
+                resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
         }
 
         function getTypeFacts(type: Type): TypeFacts {
@@ -9687,8 +9699,9 @@ namespace ts {
                 if (!key) {
                     key = getFlowCacheKey(reference);
                 }
-                if (cache[key]) {
-                    return cache[key];
+                const cached = cache.get(key);
+                if (cached) {
+                    return cached;
                 }
                 // If this flow loop junction and reference are already being processed, return
                 // the union of the types computed for each branch so far, marked as incomplete.
@@ -9722,8 +9735,9 @@ namespace ts {
                     // If we see a value appear in the cache it is a sign that control flow  analysis
                     // was restarted and completed by checkExpressionCached. We can simply pick up
                     // the resulting type and bail out.
-                    if (cache[key]) {
-                        return cache[key];
+                    const cached = cache.get(key);
+                    if (cached) {
+                        return cached;
                     }
                     if (!contains(antecedentTypes, type)) {
                         antecedentTypes.push(type);
@@ -9747,7 +9761,7 @@ namespace ts {
                 if (isIncomplete(firstAntecedentType)) {
                     return createFlowType(result, /*incomplete*/ true);
                 }
-                return cache[key] = result;
+                return set(cache, key, result);
             }
 
             function isMatchingReferenceDiscriminant(expr: Expression) {
@@ -9870,14 +9884,14 @@ namespace ts {
                     // We narrow a non-union type to an exact primitive type if the non-union type
                     // is a supertype of that primitive type. For example, type 'any' can be narrowed
                     // to one of the primitive types.
-                    const targetType = typeofTypesByName[literal.text];
+                    const targetType = typeofTypesByName.get(literal.text);
                     if (targetType && isTypeSubtypeOf(targetType, type)) {
                         return targetType;
                     }
                 }
                 const facts = assumeTrue ?
-                    typeofEQFacts[literal.text] || TypeFacts.TypeofEQHostObject :
-                    typeofNEFacts[literal.text] || TypeFacts.TypeofNEHostObject;
+                    typeofEQFacts.get(literal.text) || TypeFacts.TypeofEQHostObject :
+                    typeofNEFacts.get(literal.text) || TypeFacts.TypeofNEHostObject;
                 return getTypeWithFacts(type, facts);
             }
 
@@ -11524,7 +11538,7 @@ namespace ts {
                     }
                 }
                 else {
-                    propertiesTable[member.name] = member;
+                    propertiesTable.set(member.name, member);
                 }
                 propertiesArray.push(member);
             }
@@ -11533,12 +11547,12 @@ namespace ts {
             // type with those properties for which the binding pattern specifies a default value.
             if (contextualTypeHasPattern) {
                 for (const prop of getPropertiesOfType(contextualType)) {
-                    if (!propertiesTable[prop.name]) {
+                    if (!propertiesTable.get(prop.name)) {
                         if (!(prop.flags & SymbolFlags.Optional)) {
                             error(prop.valueDeclaration || (<TransientSymbol>prop).bindingElement,
                                 Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
                         }
-                        propertiesTable[prop.name] = prop;
+                        propertiesTable.set(prop.name, prop);
                         propertiesArray.push(prop);
                     }
                 }
@@ -11676,7 +11690,7 @@ namespace ts {
                 checkTypeAssignableTo(exprType, correspondingPropType, node);
             }
 
-            nameTable[node.name.text] = true;
+            nameTable.set(node.name.text, true);
             return exprType;
         }
 
@@ -11689,24 +11703,25 @@ namespace ts {
             for (const prop of props) {
                 // Is there a corresponding property in the element attributes type? Skip checking of properties
                 // that have already been assigned to, as these are not actually pushed into the resulting type
-                if (!nameTable[prop.name]) {
+                if (!nameTable.get(prop.name)) {
                     const targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
                     if (targetPropSym) {
                         const msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name);
                         checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg);
                     }
 
-                    nameTable[prop.name] = true;
+                    nameTable.set(prop.name, true);
                 }
             }
             return type;
         }
 
         function getJsxType(name: string) {
-            if (jsxTypes[name] === undefined) {
-                return jsxTypes[name] = getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType;
+            const jsxType = jsxTypes.get(name);
+            if (jsxType === undefined) {
+                return set(jsxTypes, name, getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType);
             }
-            return jsxTypes[name];
+            return jsxType;
         }
 
         /**
@@ -12039,11 +12054,9 @@ namespace ts {
             // was spreaded in, though, assume that it provided all required properties
             if (targetAttributesType && !sawSpreadedAny) {
                 const targetProperties = getPropertiesOfType(targetAttributesType);
-                for (let i = 0; i < targetProperties.length; i++) {
-                    if (!(targetProperties[i].flags & SymbolFlags.Optional) &&
-                        !nameTable[targetProperties[i].name]) {
-
-                        error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType));
+                for (const targetProperty of targetProperties) {
+                    if (!(targetProperty.flags & SymbolFlags.Optional) && !nameTable.get(targetProperty.name)) {
+                        error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperty.name, typeToString(targetAttributesType));
                     }
                 }
             }
@@ -15462,17 +15475,17 @@ namespace ts {
             }
 
             function addName(names: Map<Accessor>, location: Node, name: string, meaning: Accessor) {
-                const prev = names[name];
+                const prev = names.get(name);
                 if (prev) {
                     if (prev & meaning) {
                         error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
                     }
                     else {
-                        names[name] = prev | meaning;
+                        names.set(name, prev | meaning);
                     }
                 }
                 else {
-                    names[name] = meaning;
+                    names.set(name, meaning);
                 }
             }
         }
@@ -15492,12 +15505,12 @@ namespace ts {
                             continue;
                     }
 
-                    if (names[memberName]) {
+                    if (names.get(memberName)) {
                         error(member.symbol.valueDeclaration.name, Diagnostics.Duplicate_identifier_0, memberName);
                         error(member.name, Diagnostics.Duplicate_identifier_0, memberName);
                     }
                     else {
-                        names[memberName] = true;
+                        names.set(memberName, true);
                     }
                 }
             }
@@ -16681,8 +16694,7 @@ namespace ts {
 
         function checkUnusedLocalsAndParameters(node: Node): void {
             if (node.parent.kind !== SyntaxKind.InterfaceDeclaration && noUnusedIdentifiers && !isInAmbientContext(node)) {
-                for (const key in node.locals) {
-                    const local = node.locals[key];
+                node.locals.forEach(local => {
                     if (!local.isReferenced) {
                         if (local.valueDeclaration && getRootDeclaration(local.valueDeclaration).kind === SyntaxKind.Parameter) {
                             const parameter = <ParameterDeclaration>getRootDeclaration(local.valueDeclaration);
@@ -16697,7 +16709,7 @@ namespace ts {
                             forEach(local.declarations, d => errorUnusedLocal(d.name || d, local.name));
                         }
                     }
-                }
+                });
             }
         }
 
@@ -16763,8 +16775,7 @@ namespace ts {
 
         function checkUnusedModuleMembers(node: ModuleDeclaration | SourceFile): void {
             if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
-                for (const key in node.locals) {
-                    const local = node.locals[key];
+                node.locals.forEach(local => {
                     if (!local.isReferenced && !local.exportSymbol) {
                         for (const declaration of local.declarations) {
                             if (!isAmbientModule(declaration)) {
@@ -16772,7 +16783,7 @@ namespace ts {
                             }
                         }
                     }
-                }
+                });
             }
         }
 
@@ -17801,12 +17812,12 @@ namespace ts {
                     else {
                         const blockLocals = catchClause.block.locals;
                         if (blockLocals) {
-                            for (const caughtName in catchClause.locals) {
-                                const blockLocal = blockLocals[caughtName];
+                            forEachKeyInMap(catchClause.locals, caughtName => {
+                                const blockLocal = blockLocals.get(caughtName);
                                 if (blockLocal && (blockLocal.flags & SymbolFlags.BlockScopedVariable) !== 0) {
                                     grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
                                 }
-                            }
+                            });
                         }
                     }
                 }
@@ -18230,15 +18241,15 @@ namespace ts {
             }
 
             const seen = createMap<{ prop: Symbol; containingType: Type }>();
-            forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen[p.name] = { prop: p, containingType: type }; });
+            forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen.set(p.name, { prop: p, containingType: type }); });
             let ok = true;
 
             for (const base of baseTypes) {
                 const properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
                 for (const prop of properties) {
-                    const existing = seen[prop.name];
+                    const existing = seen.get(prop.name);
                     if (!existing) {
-                        seen[prop.name] = { prop: prop, containingType: base };
+                        seen.set(prop.name, { prop: prop, containingType: base });
                     }
                     else {
                         const isInheritedProperty = existing.containingType !== type;
@@ -18980,19 +18991,14 @@ namespace ts {
         }
 
         function hasExportedMembers(moduleSymbol: Symbol) {
-            for (const id in moduleSymbol.exports) {
-                if (id !== "export=") {
-                    return true;
-                }
-            }
-            return false;
+            return someKeyInMap(moduleSymbol.exports, id => id !== "export=");
         }
 
         function checkExternalModuleExports(node: SourceFile | ModuleDeclaration) {
             const moduleSymbol = getSymbolOfNode(node);
             const links = getSymbolLinks(moduleSymbol);
             if (!links.exportsChecked) {
-                const exportEqualsSymbol = moduleSymbol.exports["export="];
+                const exportEqualsSymbol = moduleSymbol.exports.get("export=");
                 if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
                     const declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
                     if (!isTopLevelInExternalModuleAugmentation(declaration)) {
@@ -19001,21 +19007,20 @@ namespace ts {
                 }
                 // Checks for export * conflicts
                 const exports = getExportsOfModule(moduleSymbol);
-                for (const id in exports) {
+                exports && exports.forEach(({ declarations, flags }, id) => {
                     if (id === "__export") {
-                        continue;
+                        return;
                     }
-                    const { declarations, flags } = exports[id];
                     // ECMA262: 15.2.1.1 It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
                     // (TS Exceptions: namespaces, function overloads, enums, and interfaces)
                     if (flags & (SymbolFlags.Namespace | SymbolFlags.Interface | SymbolFlags.Enum)) {
-                        continue;
+                        return;
                     }
                     const exportedDeclarationsCount = countWhere(declarations, isNotOverload);
                     if (flags & SymbolFlags.TypeAlias && exportedDeclarationsCount <= 2) {
                         // it is legal to merge type alias with other values
                         // so count should be either 1 (just type alias) or 2 (type alias + merged value)
-                        continue;
+                        return;
                     }
                     if (exportedDeclarationsCount > 1) {
                         for (const declaration of declarations) {
@@ -19024,7 +19029,7 @@ namespace ts {
                             }
                         }
                     }
-                }
+                });
                 links.exportsChecked = true;
             }
 
@@ -19407,18 +19412,17 @@ namespace ts {
                     // We will copy all symbol regardless of its reserved name because
                     // symbolsToArray will check whether the key is a reserved name and
                     // it will not copy symbol with reserved name to the array
-                    if (!symbols[id]) {
-                        symbols[id] = symbol;
+                    if (!symbols.has(id)) {
+                        symbols.set(id, symbol);
                     }
                 }
             }
 
             function copySymbols(source: SymbolTable, meaning: SymbolFlags): void {
                 if (meaning) {
-                    for (const id in source) {
-                        const symbol = source[id];
+                    source.forEach(symbol => {
                         copySymbol(symbol, meaning);
-                    }
+                    });
                 }
             }
         }
@@ -19829,8 +19833,8 @@ namespace ts {
             const propsByName = createSymbolTable(getPropertiesOfType(type));
             if (getSignaturesOfType(type, SignatureKind.Call).length || getSignaturesOfType(type, SignatureKind.Construct).length) {
                 forEach(getPropertiesOfType(globalFunctionType), p => {
-                    if (!propsByName[p.name]) {
-                        propsByName[p.name] = p;
+                    if (!propsByName.has(p.name)) {
+                        propsByName.set(p.name, p);
                     }
                 });
             }
@@ -19897,7 +19901,7 @@ namespace ts {
                 // otherwise - check if at least one export is value
                 symbolLinks.exportsSomeValue = hasExportAssignment
                     ? !!(moduleSymbol.flags & SymbolFlags.Value)
-                    : forEachProperty(getExportsOfModule(moduleSymbol), isValue);
+                    : someInMap(getExportsOfModule(moduleSymbol), isValue);
             }
 
             return symbolLinks.exportsSomeValue;
@@ -20247,7 +20251,7 @@ namespace ts {
         }
 
         function hasGlobalName(name: string): boolean {
-            return !!globals[name];
+            return globals.has(name);
         }
 
         function getReferencedValueSymbol(reference: Identifier, startInDeclarationContainer?: boolean): Symbol {
@@ -20304,14 +20308,13 @@ namespace ts {
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = createFileMap<string>();
-                for (const key in resolvedTypeReferenceDirectives) {
-                    const resolvedDirective = resolvedTypeReferenceDirectives[key];
+                resolvedTypeReferenceDirectives.forEach((resolvedDirective, key) => {
                     if (!resolvedDirective) {
-                        continue;
+                        return;
                     }
                     const file = host.getSourceFile(resolvedDirective.resolvedFileName);
                     fileToDirective.set(file.path, key);
-                }
+                });
             }
             return {
                 getReferencedExportContainer,
@@ -20455,11 +20458,11 @@ namespace ts {
                 if (file.symbol && file.symbol.globalExports) {
                     // Merge in UMD exports with first-in-wins semantics (see #9771)
                     const source = file.symbol.globalExports;
-                    for (const id in source) {
-                        if (!(id in globals)) {
-                            globals[id] = source[id];
+                    source.forEach((sourceSymbol, id) => {
+                        if (!globals.has(id)) {
+                            globals.set(id, sourceSymbol);
                         }
-                    }
+                    });
                 }
             }
 
@@ -21211,17 +21214,17 @@ namespace ts {
                     continue;
                 }
 
-                if (!seen[effectiveName]) {
-                    seen[effectiveName] = currentKind;
+                const existingKind = seen.get(effectiveName);
+                if (!existingKind) {
+                    seen.set(effectiveName, currentKind);
                 }
                 else {
-                    const existingKind = seen[effectiveName];
                     if (currentKind === Property && existingKind === Property) {
                         grammarErrorOnNode(name, Diagnostics.Duplicate_identifier_0, getTextOfNode(name));
                     }
                     else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) {
                         if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) {
-                            seen[effectiveName] = currentKind | existingKind;
+                            seen.set(effectiveName, currentKind | existingKind);
                         }
                         else {
                             return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
@@ -21243,8 +21246,8 @@ namespace ts {
 
                 const jsxAttr = (<JsxAttribute>attr);
                 const name = jsxAttr.name;
-                if (!seen[name.text]) {
-                    seen[name.text] = true;
+                if (!seen.get(name.text)) {
+                    seen.set(name.text, true);
                 }
                 else {
                     return grammarErrorOnNode(name, Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
@@ -21741,11 +21744,11 @@ namespace ts {
 
         function getAmbientModules(): Symbol[] {
             const result: Symbol[] = [];
-            for (const sym in globals) {
+            globals.forEach((global, sym) => {
                 if (ambientModuleSymbolRegex.test(sym)) {
-                    result.push(globals[sym]);
+                    result.push(global);
                 }
-            }
+            });
             return result;
         }
     }
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 025218e62fd..7571804b5f4 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -531,9 +531,9 @@ namespace ts {
         const optionNameMap = createMap<CommandLineOption>();
         const shortOptionNames = createMap<string>();
         forEach(optionDeclarations, option => {
-            optionNameMap[option.name.toLowerCase()] = option;
+            optionNameMap.set(option.name.toLowerCase(), option);
             if (option.shortName) {
-                shortOptionNames[option.shortName] = option.name;
+                shortOptionNames.set(option.shortName, option.name);
             }
         });
 
@@ -543,7 +543,7 @@ namespace ts {
 
     /* @internal */
     export function createCompilerDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType): Diagnostic {
-        const namesOfType = Object.keys(opt.type).map(key => `'${key}'`).join(", ");
+        const namesOfType = keysOfMap(opt.type).map(key => `'${key}'`).join(", ");
         return createCompilerDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
     }
 
@@ -598,13 +598,13 @@ namespace ts {
                     s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();
 
                     // Try to translate short option names to their full equivalents.
-                    if (s in shortOptionNames) {
-                        s = shortOptionNames[s];
+                    const short = shortOptionNames.get(s);
+                    if (short !== undefined) {
+                        s = short;
                     }
 
-                    if (s in optionNameMap) {
-                        const opt = optionNameMap[s];
-
+                    const opt = optionNameMap.get(s);
+                    if (opt) {
                         if (opt.isTSConfigOnly) {
                             errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));
                         }
@@ -727,7 +727,7 @@ namespace ts {
      * @param fileNames array of filenames to be generated into tsconfig.json
      */
     /* @internal */
-    export function generateTSConfig(options: CompilerOptions, fileNames: string[]): { compilerOptions: Map<CompilerOptionsValue> } {
+    export function generateTSConfig(options: CompilerOptions, fileNames: string[]): { compilerOptions: MapLike<CompilerOptionsValue> } {
         const compilerOptions = extend(options, defaultInitCompilerOptions);
         const configurations: any = {
             compilerOptions: serializeCompilerOptions(compilerOptions)
@@ -752,18 +752,17 @@ namespace ts {
             }
         }
 
-        function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: MapLike<string | number>): string | undefined {
+        function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: Map<string | number>): string | undefined {
             // There is a typeMap associated with this command-line option so use it to map value back to its name
-            for (const key in customTypeMap) {
-                if (customTypeMap[key] === value) {
+            return forEachInMap(customTypeMap, (mapValue, key) => {
+                if (mapValue === value) {
                     return key;
                 }
-            }
-            return undefined;
+            });
         }
 
-        function serializeCompilerOptions(options: CompilerOptions): Map<CompilerOptionsValue> {
-            const result = createMap<CompilerOptionsValue>();
+        function serializeCompilerOptions(options: CompilerOptions): MapLike<CompilerOptionsValue> {
+            const result = createMapLike<CompilerOptionsValue>();
             const optionsNameMap = getOptionNameMap().optionNameMap;
 
             for (const name in options) {
@@ -779,7 +778,7 @@ namespace ts {
                             break;
                         default:
                             const value = options[name];
-                            let optionDefinition = optionsNameMap[name.toLowerCase()];
+                            let optionDefinition = optionsNameMap.get(name.toLowerCase());
                             if (optionDefinition) {
                                 const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
                                 if (!customTypeMap) {
@@ -1049,8 +1048,8 @@ namespace ts {
         const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
 
         for (const id in jsonOptions) {
-            if (id in optionNameMap) {
-                const opt = optionNameMap[id];
+            const opt = optionNameMap.get(id);
+            if (opt) {
                 defaultOptions[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
             }
             else {
@@ -1086,8 +1085,9 @@ namespace ts {
 
     function convertJsonOptionOfCustomType(opt: CommandLineOptionOfCustomType, value: string, errors: Diagnostic[]) {
         const key = value.toLowerCase();
-        if (key in opt.type) {
-            return opt.type[key];
+        const val = opt.type.get(key);
+        if (val !== undefined) {
+            return val;
         }
         else {
             errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
@@ -1215,7 +1215,7 @@ namespace ts {
         // file map that marks whether it was a regular wildcard match (with a `*` or `?` token),
         // or a recursive directory. This information is used by filesystem watchers to monitor for
         // new entries in these paths.
-        const wildcardDirectories: Map<WatchDirectoryFlags> = getWildcardDirectories(include, exclude, basePath, host.useCaseSensitiveFileNames);
+        const wildcardDirectories = getWildcardDirectories(include, exclude, basePath, host.useCaseSensitiveFileNames);
 
         // Rather than requery this for each file and filespec, we query the supported extensions
         // once and store it on the expansion context.
@@ -1226,7 +1226,7 @@ namespace ts {
         if (fileNames) {
             for (const fileName of fileNames) {
                 const file = combinePaths(basePath, fileName);
-                literalFileMap[keyMapper(file)] = file;
+                literalFileMap.set(keyMapper(file), file);
             }
         }
 
@@ -1249,14 +1249,14 @@ namespace ts {
                 removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
 
                 const key = keyMapper(file);
-                if (!(key in literalFileMap) && !(key in wildcardFileMap)) {
-                    wildcardFileMap[key] = file;
+                if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
+                    wildcardFileMap.set(key, file);
                 }
             }
         }
 
-        const literalFiles = reduceProperties(literalFileMap, addFileToOutput, []);
-        const wildcardFiles = reduceProperties(wildcardFileMap, addFileToOutput, []);
+        const literalFiles = valuesOfMap(literalFileMap);
+        const wildcardFiles = valuesOfMap(wildcardFileMap);
         wildcardFiles.sort(host.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
         return {
             fileNames: literalFiles.concat(wildcardFiles),
@@ -1287,7 +1287,7 @@ namespace ts {
     /**
      * Gets directories in a set of include patterns that should be watched for changes.
      */
-    function getWildcardDirectories(include: string[], exclude: string[], path: string, useCaseSensitiveFileNames: boolean): Map<WatchDirectoryFlags> {
+    function getWildcardDirectories(include: string[], exclude: string[], path: string, useCaseSensitiveFileNames: boolean): MapLike<WatchDirectoryFlags> {
         // We watch a directory recursively if it contains a wildcard anywhere in a directory segment
         // of the pattern:
         //
@@ -1302,7 +1302,7 @@ namespace ts {
         //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
         const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
         const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
-        const wildcardDirectories = createMap<WatchDirectoryFlags>();
+        const wildcardDirectories = createMapLike<WatchDirectoryFlags>();
         if (include !== undefined) {
             const recursiveKeys: string[] = [];
             for (const file of include) {
@@ -1331,7 +1331,7 @@ namespace ts {
                         delete wildcardDirectories[key];
                     }
                 }
-            }
+            };
         }
 
         return wildcardDirectories;
@@ -1365,7 +1365,7 @@ namespace ts {
         for (let i = ExtensionPriority.Highest; i < adjustedExtensionPriority; i++) {
             const higherPriorityExtension = extensions[i];
             const higherPriorityPath = keyMapper(changeExtension(file, higherPriorityExtension));
-            if (higherPriorityPath in literalFiles || higherPriorityPath in wildcardFiles) {
+            if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
                 return true;
             }
         }
@@ -1387,21 +1387,10 @@ namespace ts {
         for (let i = nextExtensionPriority; i < extensions.length; i++) {
             const lowerPriorityExtension = extensions[i];
             const lowerPriorityPath = keyMapper(changeExtension(file, lowerPriorityExtension));
-            delete wildcardFiles[lowerPriorityPath];
+            wildcardFiles.delete(lowerPriorityPath);
         }
     }
 
-    /**
-     * Adds a file to an array of files.
-     *
-     * @param output The output array.
-     * @param file The file path.
-     */
-    function addFileToOutput(output: string[], file: string) {
-        output.push(file);
-        return output;
-    }
-
     /**
      * Gets a case sensitive key.
      *
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index dec6b7cc485..affd225b3a7 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -23,13 +23,13 @@ namespace ts {
         True = -1
     }
 
-    const createObject = Object.create;
-
     // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
     export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
 
-    export function createMap<T>(template?: MapLike<T>): Map<T> {
-        const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
+    const createObject = Object.create;
+    /** Create a MapLike with good performance. Prefer this over a literal `{}`. */
+    export function createMapLike<T>(): MapLike<T> {
+        const map = createObject(null); // tslint:disable-line:no-null-keyword
 
         // Using 'delete' on an object causes V8 to put the object in dictionary mode.
         // This disables creation of hidden classes, which are expensive when an object is
@@ -37,17 +37,141 @@ namespace ts {
         map["__"] = undefined;
         delete map["__"];
 
+        return map;
+    }
+
+    /** Create a new map. If a template object is provided, the map will copy entries from it. */
+    export function createMap<T>(template?: MapLike<T>): Map<T> {
+        const map: Map<T> = new MapCtr<T>();
+
         // Copies keys/values from template. Note that for..in will not throw if
         // template is undefined, and instead will just exit the loop.
         for (const key in template) if (hasOwnProperty.call(template, key)) {
-            map[key] = template[key];
+            map.set(key, template[key]);
         }
 
         return map;
     }
 
+    /** Create a map from [key, value] pairs. This avoids casting keys to strings. */
+    export function createMapFromPairs<T>(...pairs: [number, T][]): Map<T> {
+        const map: Map<T> = new MapCtr<T>();
+
+        for (const [key, value] of pairs) {
+            map.set(key, value);
+        }
+
+        return map;
+    }
+
+    /** Methods on native maps but not on shim maps. Only used in this file. */
+    interface ES6Map<T> extends Map<T> {
+        readonly size: number;
+        entries(): Iterator<[string, T]>;
+        keys(): Iterator<string>;
+    }
+
+    /** ES6 Iterator type. */
+    interface Iterator<T> {
+        next(): { value: T, done: false } | { value: never, done: true };
+    }
+
+    /** Shim maps support certain methods directly. For native maps we use a function. */
+    interface ShimMap<T> extends Map<T> {
+        isEmpty(): boolean;
+        forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined;
+        forEachKey<U>(callback: (key: string) => U | undefined): U | undefined;
+        some(predicate: (value: T, key: string) => boolean): boolean;
+        someKey(predicate: (key: string) => boolean): boolean;
+    }
+
+    // The global Map object. This may not be available, so we must test for it.
+    declare const Map: { new<T>(): Map<T> } | undefined;
+    // Internet Explorer's Map doesn't support iteration, so don't use it.
+    // tslint:disable-next-line:no-in-operator
+    const usingNativeMaps = typeof Map !== "undefined" && "entries" in Map.prototype;
+    const MapCtr = usingNativeMaps ? Map : shimMap();
+
+    // Keep the class inside a function so it doesn't get compiled if it's not used.
+    function shimMap(): { new<T>(): Map<T> } {
+        return class<T> implements ShimMap<T> {
+            private data = createMapLike<T>();
+
+            get(key: MapKey): T {
+                return this.data[key];
+            }
+
+            set(key: MapKey, value: T): this {
+                this.data[key] = value;
+                return this;
+            }
+
+            has(key: MapKey): boolean {
+                // tslint:disable-next-line:no-in-operator
+                return key in this.data;
+            }
+
+            delete(key: MapKey): boolean {
+                const had = this.has(key);
+                if (had) {
+                    delete this.data[key];
+                }
+                return had;
+            }
+
+            clear(): void {
+                this.data = createMapLike<T>();
+            }
+
+            forEach(action: (value: T, key: string) => void): void {
+                for (const key in this.data) {
+                    action(this.data[key], key);
+                }
+            }
+
+            isEmpty(): boolean {
+                return !this.someKey(() => true);
+            }
+
+            forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined {
+                return this.forEachKey(key => callback(this.data[key], key));
+            }
+
+            forEachKey<U>(callback: (key: string) => U | undefined): U | undefined {
+                for (const key in this.data) {
+                    const result = callback(key);
+                    if (result !== undefined) {
+                        return result;
+                    }
+                }
+            }
+
+            some(predicate: (value: T, key: string) => boolean): boolean {
+                return this.someKey(key => predicate(this.data[key], key));
+            }
+
+            someKey(predicate: (key: string) => boolean): boolean {
+                for (const key in this.data) {
+                    if (predicate(key)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+    }
+
+    /**
+     * Unlike `map.set(key, value)`, this returns the value, making it useful as an expression.
+     * Prefer `map.set(key, value)` for statements.
+     */
+    export function set<T>(map: Map<T>, key: MapKey, value: T): T {
+        map.set(key, value);
+        return value;
+    }
+
     export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
-        let files = createMap<T>();
+        const files = createMap<T>();
         return {
             get,
             set,
@@ -59,39 +183,34 @@ namespace ts {
         };
 
         function forEachValueInMap(f: (key: Path, value: T) => void) {
-            for (const key in files) {
-                f(<Path>key, files[key]);
-            }
+            files.forEach((file, key) => {
+                f(<Path>key, file);
+            });
         }
 
         function getKeys() {
-            const keys: Path[] = [];
-            for (const key in files) {
-                keys.push(<Path>key);
-            }
-            return keys;
+            return keysOfMap(files) as Path[];
         }
 
         // path should already be well-formed so it does not need to be normalized
         function get(path: Path): T {
-            return files[toKey(path)];
+            return files.get(toKey(path));
         }
 
         function set(path: Path, value: T) {
-            files[toKey(path)] = value;
+            files.set(toKey(path), value);
         }
 
         function contains(path: Path) {
-            return toKey(path) in files;
+            return files.has(toKey(path));
         }
 
         function remove(path: Path) {
-            const key = toKey(path);
-            delete files[key];
+            files.delete(toKey(path));
         }
 
         function clear() {
-            files = createMap<T>();
+            files.clear();
         }
 
         function toKey(path: Path): string {
@@ -748,9 +867,6 @@ namespace ts {
     /**
      * Indicates whether a map-like contains an own property with the specified key.
      *
-     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
-     *       the 'in' operator.
-     *
      * @param map A map-like.
      * @param key A property key.
      */
@@ -761,9 +877,6 @@ namespace ts {
     /**
      * Gets the value of an owned property in a map-like.
      *
-     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
-     *       an indexer.
-     *
      * @param map A map-like.
      * @param key A property key.
      */
@@ -788,49 +901,86 @@ namespace ts {
     }
 
     /**
-     * Enumerates the properties of a Map<T>, invoking a callback and returning the first truthy result.
-     *
-     * @param map A map for which properties should be enumerated.
-     * @param callback A callback to invoke for each property.
+     * Array of every key in a map.
+     * May not actually return string[] if numbers were put into the map.
      */
-    export function forEachProperty<T, U>(map: Map<T>, callback: (value: T, key: string) => U): U {
-        let result: U;
-        for (const key in map) {
-            if (result = callback(map[key], key)) break;
-        }
-        return result;
+    export function keysOfMap<T>(map: Map<T>): string[] {
+        const keys: string[] = [];
+        forEachKeyInMap(map, key => {
+            keys.push(key);
+        });
+        return keys;
+    }
+
+    /** Array of every value in a map. */
+    export function valuesOfMap<T>(map: Map<T>): T[] {
+        const values: T[] = [];
+        map.forEach(value => {
+            values.push(value);
+        });
+        return values;
     }
 
     /**
-     * Returns true if a Map<T> has some matching property.
-     *
-     * @param map A map whose properties should be tested.
-     * @param predicate An optional callback used to test each property.
+     * Calls `callback` for each entry in the map, returning the first defined result.
+     * Use `map.forEach` instead for normal iteration.
      */
-    export function someProperties<T>(map: Map<T>, predicate?: (value: T, key: string) => boolean) {
-        for (const key in map) {
-            if (!predicate || predicate(map[key], key)) return true;
+    export const forEachInMap: <T, U>(map: Map<T>, callback: (value: T, key: string) => U | undefined) => U | undefined = usingNativeMaps
+        ? <T, U>(map: ES6Map<T>, callback: (value: T, key: string) => U | undefined) => {
+            const iterator = map.entries();
+            while (true) {
+                const { value: pair, done } = iterator.next();
+                if (done) return undefined;
+                const [key, value] = pair;
+                const result = callback(value, key);
+                if (result !== undefined) return result;
+            }
         }
-        return false;
-    }
+        : <T, U>(map: ShimMap<T>, callback: (value: T, key: string) => U | undefined) => map.forEachInMap(callback);
 
-    /**
-     * Performs a shallow copy of the properties from a source Map<T> to a target MapLike<T>
-     *
-     * @param source A map from which properties should be copied.
-     * @param target A map to which properties should be copied.
-     */
-    export function copyProperties<T>(source: Map<T>, target: MapLike<T>): void {
-        for (const key in source) {
-            target[key] = source[key];
+    /** `forEachInMap` for just keys. */
+    export const forEachKeyInMap: <T>(map: Map<{}>, callback: (key: string) => T | undefined) => T | undefined = usingNativeMaps
+        ? <T>(map: ES6Map<T>, callback: (key: string) => T | undefined) => {
+            const iterator = map.keys();
+            while (true) {
+                const { value: key, done } = iterator.next();
+                if (done) return undefined;
+                const result = callback(key);
+                if (result !== undefined) return result;
+            }
         }
-    }
+        : <T>(map: ShimMap<T>, callback: (key: string) => T | undefined) => map.forEachKey(callback);
 
-    export function appendProperty<T>(map: Map<T>, key: string | number, value: T): Map<T> {
-        if (key === undefined || value === undefined) return map;
-        if (map === undefined) map = createMap<T>();
-        map[key] = value;
-        return map;
+    /** Whether `predicate` is true for some entry in the map. */
+    export const someInMap: <T>(map: Map<T>, predicate: (value: T, key: string) => boolean) => boolean = usingNativeMaps
+        ? <T>(map: ES6Map<T>, predicate: (value: T, key: string) => boolean) => {
+            const iterator = map.entries();
+            while (true) {
+                const { value: pair, done } = iterator.next();
+                if (done) return false;
+                const [key, value] = pair;
+                if (predicate(value, key)) return true;
+            }
+        }
+        : <T>(map: ShimMap<T>, predicate: (value: T, key: string) => boolean) => map.some(predicate);
+
+    /** Whether `predicate` is true for some key in the map. */
+    export const someKeyInMap: (map: Map<{}>, predicate: (key: string) => boolean) => boolean = usingNativeMaps
+        ? (map: ES6Map<{}>, predicate: (key: string) => boolean) => {
+            const iterator = map.keys();
+            while (true) {
+                const { value: key, done } = iterator.next();
+                if (done) return false;
+                if (predicate(key)) return true;
+            }
+        }
+        : (map: ShimMap<{}>, predicate: (key: string) => boolean) => map.someKey(predicate);
+
+    /** Copy entries from `source` to `target`. */
+    export function copyMapEntries<T>(source: Map<T>, target: Map<T>): void {
+        source.forEach((value, key) => {
+            target.set(key, value);
+        });
     }
 
     export function assign<T1 extends MapLike<{}>, T2, T3>(t: T1, arg1: T2, arg2: T3): T1 & T2 & T3;
@@ -845,24 +995,6 @@ namespace ts {
         return t;
     }
 
-    /**
-     * Reduce the properties of a map.
-     *
-     * NOTE: This is intended for use with Map<T> objects. For MapLike<T> objects, use
-     *       reduceOwnProperties instead as it offers better runtime safety.
-     *
-     * @param map The map to reduce
-     * @param callback An aggregation function that is called for each entry in the map
-     * @param initial The initial value for the reduction.
-     */
-    export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
-        let result = initial;
-        for (const key in map) {
-            result = callback(result, map[key], String(key));
-        }
-        return result;
-    }
-
     /**
      * Performs a shallow equality comparison of the contents of two map-likes.
      *
@@ -882,6 +1014,20 @@ namespace ts {
         return true;
     }
 
+    /** True if the maps have the same keys and values. */
+    export function mapsAreEqual<T>(left: Map<T>, right: Map<T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
+        if (left === right) return true;
+        if (!left || !right) return false;
+        const someInLeftHasNoMatch = someInMap(left, (leftValue, leftKey) => {
+            if (!right.has(leftKey)) return true;
+            const rightValue = right.get(leftKey);
+            return !(valuesAreEqual ? valuesAreEqual(leftValue, rightValue) : leftValue === rightValue);
+        });
+        if (someInLeftHasNoMatch) return false;
+        const someInRightHasNoMatch = someKeyInMap(right, rightKey => !left.has(rightKey));
+        return !someInRightHasNoMatch;
+    }
+
     /**
      * Creates a map from the elements of an array.
      *
@@ -897,23 +1043,18 @@ namespace ts {
     export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue?: (value: T) => U): Map<T | U> {
         const result = createMap<T | U>();
         for (const value of array) {
-            result[makeKey(value)] = makeValue ? makeValue(value) : value;
+            result.set(makeKey(value), makeValue ? makeValue(value) : value);
         }
         return result;
     }
 
-    export function isEmpty<T>(map: Map<T>) {
-        for (const id in map) {
-            if (hasProperty(map, id)) {
-                return false;
-            }
-        }
-        return true;
-    }
+    export const mapIsEmpty: (map: Map<{}>) => boolean = usingNativeMaps
+        ? (map: ES6Map<{}>) => map.size === 0
+        : (map: ShimMap<{}>) => map.isEmpty();
 
     export function cloneMap<T>(map: Map<T>) {
         const clone = createMap<T>();
-        copyProperties(map, clone);
+        copyMapEntries(map, clone);
         return clone;
     }
 
@@ -943,13 +1084,13 @@ namespace ts {
      * Creates the array if it does not already exist.
      */
     export function multiMapAdd<V>(map: Map<V[]>, key: string | number, value: V): V[] {
-        const values = map[key];
+        const values = map.get(key);
         if (values) {
             values.push(value);
             return values;
         }
         else {
-            return map[key] = [value];
+            return set(map, key, [value]);
         }
     }
 
@@ -959,11 +1100,11 @@ namespace ts {
      * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
      */
     export function multiMapRemove<V>(map: Map<V[]>, key: string, value: V): void {
-        const values = map[key];
+        const values = map.get(key);
         if (values) {
             unorderedRemoveItem(values, value);
             if (!values.length) {
-                delete map[key];
+                map.delete(key);
             }
         }
     }
@@ -1066,7 +1207,7 @@ namespace ts {
         return text.replace(/{(\d+)}/g, (_match, index?) => args[+index + baseIndex]);
     }
 
-    export let localizedDiagnosticMessages: Map<string> = undefined;
+    export let localizedDiagnosticMessages: MapLike<string> = undefined;
 
     export function getLocaleSpecificMessage(message: DiagnosticMessage) {
         return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index cd98622e080..e010519d641 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -156,9 +156,9 @@ namespace ts {
         });
 
         if (usedTypeDirectiveReferences) {
-            for (const directive in usedTypeDirectiveReferences) {
+            forEachKeyInMap(usedTypeDirectiveReferences, directive => {
                 referencesOutput += `/// <reference types="${directive}" />${newLine}`;
-            }
+            });
         }
 
         return {
@@ -271,8 +271,8 @@ namespace ts {
                 usedTypeDirectiveReferences = createMap<string>();
             }
             for (const directive of typeReferenceDirectives) {
-                if (!(directive in usedTypeDirectiveReferences)) {
-                    usedTypeDirectiveReferences[directive] = directive;
+                if (!usedTypeDirectiveReferences.has(directive)) {
+                    usedTypeDirectiveReferences.set(directive, directive);
                 }
             }
         }
@@ -581,14 +581,14 @@ namespace ts {
         // do not need to keep track of created temp names.
         function getExportDefaultTempVariableName(): string {
             const baseName = "_default";
-            if (!(baseName in currentIdentifiers)) {
+            if (!currentIdentifiers.has(baseName)) {
                 return baseName;
             }
             let count = 0;
             while (true) {
                 count++;
                 const name = baseName + "_" + count;
-                if (!(name in currentIdentifiers)) {
+                if (!currentIdentifiers.has(name)) {
                     return name;
                 }
             }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 90738d828be..191a39a5797 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2031,11 +2031,11 @@ namespace ts {
                         // Skip the helper if it can be bundled but hasn't already been emitted and we
                         // are emitting a bundled module.
                         if (shouldBundle) {
-                            if (bundledHelpers[helper.name]) {
+                            if (bundledHelpers.get(helper.name)) {
                                 continue;
                             }
 
-                            bundledHelpers[helper.name] = true;
+                            bundledHelpers.set(helper.name, true);
                         }
                     }
                     else if (isBundle) {
@@ -2487,15 +2487,16 @@ namespace ts {
 
         function isUniqueName(name: string): boolean {
             return !resolver.hasGlobalName(name) &&
-                !hasProperty(currentFileIdentifiers, name) &&
-                !hasProperty(generatedNameSet, name);
+                !currentFileIdentifiers.has(name) &&
+                !generatedNameSet.has(name);
         }
 
         function isUniqueLocalName(name: string, container: Node): boolean {
             for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
-                if (node.locals && hasProperty(node.locals, name)) {
+                if (node.locals) {
+                    const local = node.locals.get(name);
                     // We conservatively include alias symbols to cover cases where they're emitted as locals
-                    if (node.locals[name].flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
+                    if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
                         return false;
                     }
                 }
@@ -2544,7 +2545,7 @@ namespace ts {
             while (true) {
                 const generatedName = baseName + i;
                 if (isUniqueName(generatedName)) {
-                    return generatedNameSet[generatedName] = generatedName;
+                    return set(generatedNameSet, generatedName, generatedName);
                 }
                 i++;
             }
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index ebcea221f9e..2ef73dea727 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -2643,7 +2643,7 @@ namespace ts {
 
     function mergeTokenSourceMapRanges(sourceRanges: Map<TextRange>, destRanges: Map<TextRange>) {
         if (!destRanges) destRanges = createMap<TextRange>();
-        copyProperties(sourceRanges, destRanges);
+        copyMapEntries(sourceRanges, destRanges);
         return destRanges;
     }
 
@@ -2745,7 +2745,7 @@ namespace ts {
     export function getTokenSourceMapRange(node: Node, token: SyntaxKind) {
         const emitNode = node.emitNode;
         const tokenSourceMapRanges = emitNode && emitNode.tokenSourceMapRanges;
-        return tokenSourceMapRanges && tokenSourceMapRanges[token];
+        return tokenSourceMapRanges && tokenSourceMapRanges.get(token);
     }
 
     /**
@@ -2758,7 +2758,7 @@ namespace ts {
     export function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: TextRange) {
         const emitNode = getOrCreateEmitNode(node);
         const tokenSourceMapRanges = emitNode.tokenSourceMapRanges || (emitNode.tokenSourceMapRanges = createMap<TextRange>());
-        tokenSourceMapRanges[token] = range;
+        tokenSourceMapRanges.set(token, range);
         return node;
     }
 
@@ -2969,10 +2969,8 @@ namespace ts {
      * Here we check if alternative name was provided for a given moduleName and return it if possible.
      */
     function tryRenameExternalModule(moduleName: LiteralExpression, sourceFile: SourceFile) {
-        if (sourceFile.renamedDependencies && hasProperty(sourceFile.renamedDependencies, moduleName.text)) {
-            return createLiteral(sourceFile.renamedDependencies[moduleName.text]);
-        }
-        return undefined;
+        const rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
+        return rename && createLiteral(rename);
     }
 
     /**
@@ -3332,7 +3330,7 @@ namespace ts {
                     else {
                         // export { x, y }
                         for (const specifier of (<ExportDeclaration>node).exportClause.elements) {
-                            if (!uniqueExports[specifier.name.text]) {
+                            if (!uniqueExports.get(specifier.name.text)) {
                                 const name = specifier.propertyName || specifier.name;
                                 multiMapAdd(exportSpecifiers, name.text, specifier);
 
@@ -3343,7 +3341,7 @@ namespace ts {
                                     multiMapAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
                                 }
 
-                                uniqueExports[specifier.name.text] = true;
+                                uniqueExports.set(specifier.name.text, true);
                                 exportedNames = append(exportedNames, specifier.name);
                             }
                         }
@@ -3377,9 +3375,9 @@ namespace ts {
                         else {
                             // export function x() { }
                             const name = (<FunctionDeclaration>node).name;
-                            if (!uniqueExports[name.text]) {
+                            if (!uniqueExports.get(name.text)) {
                                 multiMapAdd(exportedBindings, getOriginalNodeId(node), name);
-                                uniqueExports[name.text] = true;
+                                uniqueExports.set(name.text, true);
                                 exportedNames = append(exportedNames, name);
                             }
                         }
@@ -3398,9 +3396,9 @@ namespace ts {
                         else {
                             // export class x { }
                             const name = (<ClassDeclaration>node).name;
-                            if (!uniqueExports[name.text]) {
+                            if (!uniqueExports.get(name.text)) {
                                 multiMapAdd(exportedBindings, getOriginalNodeId(node), name);
-                                uniqueExports[name.text] = true;
+                                uniqueExports.set(name.text, true);
                                 exportedNames = append(exportedNames, name);
                             }
                         }
@@ -3421,8 +3419,8 @@ namespace ts {
             }
         }
         else if (!isGeneratedIdentifier(decl.name)) {
-            if (!uniqueExports[decl.name.text]) {
-                uniqueExports[decl.name.text] = true;
+            if (!uniqueExports.get(decl.name.text)) {
+                uniqueExports.set(decl.name.text, true);
                 exportedNames = append(exportedNames, decl.name);
             }
         }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 4aefa160077..3da9093ee5a 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1131,7 +1131,7 @@ namespace ts {
 
         function internIdentifier(text: string): string {
             text = escapeIdentifier(text);
-            return identifiers[text] || (identifiers[text] = text);
+            return identifiers.get(text) || set(identifiers, text, text);
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
diff --git a/src/compiler/performance.ts b/src/compiler/performance.ts
index a48eb117e28..8c24b3b9f1b 100644
--- a/src/compiler/performance.ts
+++ b/src/compiler/performance.ts
@@ -27,8 +27,8 @@ namespace ts.performance {
      */
     export function mark(markName: string) {
         if (enabled) {
-            marks[markName] = timestamp();
-            counts[markName] = (counts[markName] || 0) + 1;
+            marks.set(markName, timestamp());
+            counts.set(markName, (counts.get(markName) || 0) + 1);
             profilerEvent(markName);
         }
     }
@@ -44,9 +44,9 @@ namespace ts.performance {
      */
     export function measure(measureName: string, startMarkName?: string, endMarkName?: string) {
         if (enabled) {
-            const end = endMarkName && marks[endMarkName] || timestamp();
-            const start = startMarkName && marks[startMarkName] || profilerStart;
-            measures[measureName] = (measures[measureName] || 0) + (end - start);
+            const end = endMarkName && marks.get(endMarkName) || timestamp();
+            const start = startMarkName && marks.get(startMarkName) || profilerStart;
+            measures.set(measureName, (measures.get(measureName) || 0) + (end - start));
         }
     }
 
@@ -56,7 +56,7 @@ namespace ts.performance {
      * @param markName The name of the mark.
      */
     export function getCount(markName: string) {
-        return counts && counts[markName] || 0;
+        return counts && counts.get(markName) || 0;
     }
 
     /**
@@ -65,7 +65,7 @@ namespace ts.performance {
      * @param measureName The name of the measure whose durations should be accumulated.
      */
     export function getDuration(measureName: string) {
-        return measures && measures[measureName] || 0;
+        return measures && measures.get(measureName) || 0;
     }
 
     /**
@@ -74,9 +74,9 @@ namespace ts.performance {
      * @param cb The action to perform for each measure
      */
     export function forEachMeasure(cb: (measureName: string, duration: number) => void) {
-        for (const key in measures) {
-            cb(key, measures[key]);
-        }
+        measures.forEach((measure, key) => {
+            cb(key, measure);
+        });
     }
 
     /** Enables (and resets) performance measurements for the compiler. */
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 73976d5d02e..3da9f57ca39 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -110,11 +110,11 @@ namespace ts {
         }
 
         function directoryExists(directoryPath: string): boolean {
-            if (directoryPath in existingDirectories) {
+            if (existingDirectories.has(directoryPath)) {
                 return true;
             }
             if (sys.directoryExists(directoryPath)) {
-                existingDirectories[directoryPath] = true;
+                existingDirectories.set(directoryPath, true);
                 return true;
             }
             return false;
@@ -138,11 +138,11 @@ namespace ts {
             const hash = sys.createHash(data);
             const mtimeBefore = sys.getModifiedTime(fileName);
 
-            if (mtimeBefore && fileName in outputFingerprints) {
-                const fingerprint = outputFingerprints[fileName];
-
+            if (mtimeBefore) {
+                const fingerprint = outputFingerprints.get(fileName);
                 // If output has not been changed, and the file has no external modification
-                if (fingerprint.byteOrderMark === writeByteOrderMark &&
+                if (fingerprint &&
+                    fingerprint.byteOrderMark === writeByteOrderMark &&
                     fingerprint.hash === hash &&
                     fingerprint.mtime.getTime() === mtimeBefore.getTime()) {
                     return;
@@ -153,11 +153,11 @@ namespace ts {
 
             const mtimeAfter = sys.getModifiedTime(fileName);
 
-            outputFingerprints[fileName] = {
+            outputFingerprints.set(fileName, {
                 hash,
                 byteOrderMark: writeByteOrderMark,
                 mtime: mtimeAfter
-            };
+            });
         }
 
         function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
@@ -277,9 +277,9 @@ namespace ts {
         const resolutions: T[] = [];
         const cache = createMap<T>();
         for (const name of names) {
-            const result = name in cache
-                ? cache[name]
-                : cache[name] = loader(name, containingFile);
+            const result = cache.has(name)
+                ? cache.get(name)
+                : set(cache, name, loader(name, containingFile));
             resolutions.push(result);
         }
         return resolutions;
@@ -454,7 +454,7 @@ namespace ts {
                 classifiableNames = createMap<string>();
 
                 for (const sourceFile of files) {
-                    copyProperties(sourceFile.classifiableNames, classifiableNames);
+                    copyMapEntries(sourceFile.classifiableNames, classifiableNames);
                 }
             }
 
@@ -729,7 +729,7 @@ namespace ts {
         }
 
         function isSourceFileFromExternalLibrary(file: SourceFile): boolean {
-            return sourceFilesFoundSearchingNodeModules[file.path];
+            return sourceFilesFoundSearchingNodeModules.get(file.path);
         }
 
         function getDiagnosticsProducingTypeChecker() {
@@ -1292,20 +1292,20 @@ namespace ts {
 
                 // If the file was previously found via a node_modules search, but is now being processed as a root file,
                 // then everything it sucks in may also be marked incorrectly, and needs to be checked again.
-                if (file && sourceFilesFoundSearchingNodeModules[file.path] && currentNodeModulesDepth == 0) {
-                    sourceFilesFoundSearchingNodeModules[file.path] = false;
+                if (file && sourceFilesFoundSearchingNodeModules.get(file.path) && currentNodeModulesDepth == 0) {
+                    sourceFilesFoundSearchingNodeModules.set(file.path, false);
                     if (!options.noResolve) {
                         processReferencedFiles(file, isDefaultLib);
                         processTypeReferenceDirectives(file);
                     }
 
-                    modulesWithElidedImports[file.path] = false;
+                    modulesWithElidedImports.set(file.path, false);
                     processImportedModules(file);
                 }
                 // See if we need to reprocess the imports due to prior skipped imports
-                else if (file && modulesWithElidedImports[file.path]) {
+                else if (file && modulesWithElidedImports.get(file.path)) {
                     if (currentNodeModulesDepth < maxNodeModuleJsDepth) {
-                        modulesWithElidedImports[file.path] = false;
+                        modulesWithElidedImports.set(file.path, false);
                         processImportedModules(file);
                     }
                 }
@@ -1326,7 +1326,7 @@ namespace ts {
 
             filesByName.set(path, file);
             if (file) {
-                sourceFilesFoundSearchingNodeModules[path] = (currentNodeModulesDepth > 0);
+                sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
                 file.path = path;
 
                 if (host.useCaseSensitiveFileNames()) {
@@ -1387,7 +1387,7 @@ namespace ts {
             refFile?: SourceFile, refPos?: number, refEnd?: number): void {
 
             // If we already found this library as a primary reference - nothing to do
-            const previousResolution = resolvedTypeReferenceDirectives[typeReferenceDirective];
+            const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective);
             if (previousResolution && previousResolution.primary) {
                 return;
             }
@@ -1427,7 +1427,7 @@ namespace ts {
             }
 
             if (saveResolution) {
-                resolvedTypeReferenceDirectives[typeReferenceDirective] = resolvedTypeReferenceDirective;
+                resolvedTypeReferenceDirectives.set(typeReferenceDirective, resolvedTypeReferenceDirective);
             }
         }
 
@@ -1480,7 +1480,7 @@ namespace ts {
                     const shouldAddFile = resolvedFileName && !getResolutionDiagnostic(options, resolution) && !options.noResolve && i < file.imports.length && !elideImport;
 
                     if (elideImport) {
-                        modulesWithElidedImports[file.path] = true;
+                        modulesWithElidedImports.set(file.path, true);
                     }
                     else if (shouldAddFile) {
                         const path = toPath(resolvedFileName, currentDirectory, getCanonicalFileName);
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 82302e98e37..4f32b453ecd 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -275,9 +275,9 @@ namespace ts {
 
     function makeReverseMap(source: Map<number>): string[] {
         const result: string[] = [];
-        for (const name in source) {
-            result[source[name]] = name;
-        }
+        source.forEach((value, name) => {
+            result[value] = name;
+        });
         return result;
     }
 
@@ -289,7 +289,7 @@ namespace ts {
 
     /* @internal */
     export function stringToToken(s: string): SyntaxKind {
-        return textToToken[s];
+        return textToToken.get(s);
     }
 
     /* @internal */
@@ -363,8 +363,6 @@ namespace ts {
         return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
     }
 
-    const hasOwnProperty = Object.prototype.hasOwnProperty;
-
     export function isWhiteSpace(ch: number): boolean {
         return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
     }
@@ -1183,8 +1181,11 @@ namespace ts {
             const len = tokenValue.length;
             if (len >= 2 && len <= 11) {
                 const ch = tokenValue.charCodeAt(0);
-                if (ch >= CharacterCodes.a && ch <= CharacterCodes.z && hasOwnProperty.call(textToToken, tokenValue)) {
-                    return token = textToToken[tokenValue];
+                if (ch >= CharacterCodes.a && ch <= CharacterCodes.z) {
+                    token = textToToken.get(tokenValue);
+                    if (token !== undefined) {
+                        return token;
+                    }
                 }
             }
             return token = SyntaxKind.Identifier;
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index 650b9b0ef02..a814a91c355 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -362,7 +362,7 @@ namespace ts {
 
             const emitNode = node && node.emitNode;
             const emitFlags = emitNode && emitNode.flags;
-            const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
+            const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges.get(token);
 
             tokenPos = skipTrivia(currentSourceText, range ? range.pos : tokenPos);
             if ((emitFlags & EmitFlags.NoTokenLeadingSourceMaps) === 0 && tokenPos >= 0) {
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index a1e82a66595..c34527f8954 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -18,7 +18,7 @@ namespace ts {
         getFileSize?(path: string): number;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
         /**
-         * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that 
+         * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
          * use native OS file watching
          */
         watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number): FileWatcher;
@@ -248,18 +248,18 @@ namespace ts {
 
                 function reduceDirWatcherRefCountForFile(fileName: string) {
                     const dirName = getDirectoryPath(fileName);
-                    const watcher = dirWatchers[dirName];
+                    const watcher = dirWatchers.get(dirName);
                     if (watcher) {
                         watcher.referenceCount -= 1;
                         if (watcher.referenceCount <= 0) {
                             watcher.close();
-                            delete dirWatchers[dirName];
+                            dirWatchers.delete(dirName);
                         }
                     }
                 }
 
                 function addDirWatcher(dirPath: string): void {
-                    let watcher = dirWatchers[dirPath];
+                    let watcher = dirWatchers.get(dirPath);
                     if (watcher) {
                         watcher.referenceCount += 1;
                         return;
@@ -270,7 +270,7 @@ namespace ts {
                         (eventName: string, relativeFileName: string) => fileEventHandler(eventName, relativeFileName, dirPath)
                     );
                     watcher.referenceCount = 1;
-                    dirWatchers[dirPath] = watcher;
+                    dirWatchers.set(dirPath, watcher);
                     return;
                 }
 
@@ -300,9 +300,12 @@ namespace ts {
                         ? undefined
                         : ts.getNormalizedAbsolutePath(relativeFileName, baseDirPath);
                     // Some applications save a working file via rename operations
-                    if ((eventName === "change" || eventName === "rename") && fileWatcherCallbacks[fileName]) {
-                        for (const fileCallback of fileWatcherCallbacks[fileName]) {
-                            fileCallback(fileName);
+                    if ((eventName === "change" || eventName === "rename")) {
+                        const callbacks = fileWatcherCallbacks.get(fileName);
+                        if (callbacks) {
+                            for (const fileCallback of callbacks) {
+                                fileCallback(fileName);
+                            }
                         }
                     }
                 }
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index 10a718448e9..1440481d38e 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -13,14 +13,14 @@
 
 /* @internal */
 namespace ts {
-    const moduleTransformerMap = createMap<Transformer>({
-        [ModuleKind.ES2015]: transformES2015Module,
-        [ModuleKind.System]: transformSystemModule,
-        [ModuleKind.AMD]: transformModule,
-        [ModuleKind.CommonJS]: transformModule,
-        [ModuleKind.UMD]: transformModule,
-        [ModuleKind.None]: transformModule,
-    });
+    const moduleTransformerMap = createMapFromPairs<Transformer>(
+        [ModuleKind.ES2015, transformES2015Module],
+        [ModuleKind.System, transformSystemModule],
+        [ModuleKind.AMD, transformModule],
+        [ModuleKind.CommonJS, transformModule],
+        [ModuleKind.UMD, transformModule],
+        [ModuleKind.None, transformModule],
+    );
 
     const enum SyntaxKindFeatureFlags {
         Substitution = 1 << 0,
@@ -56,7 +56,7 @@ namespace ts {
             transformers.push(transformGenerators);
         }
 
-        transformers.push(moduleTransformerMap[moduleKind] || moduleTransformerMap[ModuleKind.None]);
+        transformers.push(moduleTransformerMap.get(moduleKind) || moduleTransformerMap.get(ModuleKind.None));
 
         // The ES5 transformer is last so that it can substitute expressions like `exports.default`
         // for ES3.
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index c1398f75da6..13c44f2d7d5 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -561,7 +561,7 @@ namespace ts {
                 //   - break/continue is non-labeled and located in non-converted loop/switch statement
                 const jump = node.kind === SyntaxKind.BreakStatement ? Jump.Break : Jump.Continue;
                 const canUseBreakOrContinue =
-                    (node.label && convertedLoopState.labels && convertedLoopState.labels[node.label.text]) ||
+                    (node.label && convertedLoopState.labels && convertedLoopState.labels.get(node.label.text)) ||
                     (!node.label && (convertedLoopState.allowedNonLabeledJumps & jump));
 
                 if (!canUseBreakOrContinue) {
@@ -1929,7 +1929,7 @@ namespace ts {
                 if (!convertedLoopState.labels) {
                     convertedLoopState.labels = createMap<string>();
                 }
-                convertedLoopState.labels[node.label.text] = node.label.text;
+                convertedLoopState.labels.set(node.label.text, node.label.text);
             }
 
             let result: VisitResult<Statement>;
@@ -1941,7 +1941,7 @@ namespace ts {
             }
 
             if (convertedLoopState) {
-                convertedLoopState.labels[node.label.text] = undefined;
+                convertedLoopState.labels.set(node.label.text, undefined);
             }
 
             return result;
@@ -2548,13 +2548,13 @@ namespace ts {
                 if (!state.labeledNonLocalBreaks) {
                     state.labeledNonLocalBreaks = createMap<string>();
                 }
-                state.labeledNonLocalBreaks[labelText] = labelMarker;
+                state.labeledNonLocalBreaks.set(labelText, labelMarker);
             }
             else {
                 if (!state.labeledNonLocalContinues) {
                     state.labeledNonLocalContinues = createMap<string>();
                 }
-                state.labeledNonLocalContinues[labelText] = labelMarker;
+                state.labeledNonLocalContinues.set(labelText, labelMarker);
             }
         }
 
@@ -2562,13 +2562,12 @@ namespace ts {
             if (!table) {
                 return;
             }
-            for (const labelText in table) {
-                const labelMarker = table[labelText];
+            table.forEach((labelMarker, labelText) => {
                 const statements: Statement[] = [];
                 // if there are no outer converted loop or outer label in question is located inside outer converted loop
                 // then emit labeled break\continue
                 // otherwise propagate pair 'label -> marker' to outer converted loop and emit 'return labelMarker' so outer loop can later decide what to do
-                if (!outerLoop || (outerLoop.labels && outerLoop.labels[labelText])) {
+                if (!outerLoop || (outerLoop.labels && outerLoop.labels.get(labelText))) {
                     const label = createIdentifier(labelText);
                     statements.push(isBreak ? createBreak(label) : createContinue(label));
                 }
@@ -2577,7 +2576,7 @@ namespace ts {
                     statements.push(createReturn(loopResultName));
                 }
                 caseClauses.push(createCaseClause(createLiteral(labelMarker), statements));
-            }
+            });
         }
 
         function processLoopVariableDeclaration(decl: VariableDeclaration | BindingElement, loopParameters: ParameterDeclaration[], loopOutParameters: LoopOutParameter[]) {
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index c383902d495..0b853649e81 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -217,13 +217,13 @@ namespace ts {
         Endfinally = 7,
     }
 
-    const instructionNames = createMap<string>({
-        [Instruction.Return]: "return",
-        [Instruction.Break]: "break",
-        [Instruction.Yield]: "yield",
-        [Instruction.YieldStar]: "yield*",
-        [Instruction.Endfinally]: "endfinally",
-    });
+    const instructionNames = createMapFromPairs<string>(
+        [Instruction.Return, "return"],
+        [Instruction.Break, "break"],
+        [Instruction.Yield, "yield"],
+        [Instruction.YieldStar, "yield*"],
+        [Instruction.Endfinally, "endfinally"],
+    );
 
     export function transformGenerators(context: TransformationContext) {
         const {
@@ -1921,12 +1921,12 @@ namespace ts {
         }
 
         function substituteExpressionIdentifier(node: Identifier) {
-            if (renamedCatchVariables && hasProperty(renamedCatchVariables, node.text)) {
+            if (renamedCatchVariables && renamedCatchVariables.has(node.text)) {
                 const original = getOriginalNode(node);
                 if (isIdentifier(original) && original.parent) {
                     const declaration = resolver.getReferencedValueDeclaration(original);
                     if (declaration) {
-                        const name = getProperty(renamedCatchVariableDeclarations, String(getOriginalNodeId(declaration)));
+                        const name = renamedCatchVariableDeclarations.get(getOriginalNodeId(declaration));
                         if (name) {
                             const clone = getMutableClone(name);
                             setSourceMapRange(clone, node);
@@ -2096,8 +2096,8 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
 
-            renamedCatchVariables[text] = true;
-            renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name;
+            renamedCatchVariables.set(text, true);
+            renamedCatchVariableDeclarations.set(getOriginalNodeId(variable), name);
 
             const exception = <ExceptionBlock>peekBlock();
             Debug.assert(exception.state < ExceptionBlockState.Catch);
@@ -2401,7 +2401,7 @@ namespace ts {
          */
         function createInstruction(instruction: Instruction): NumericLiteral {
             const literal = createLiteral(instruction);
-            literal.trailingComment = instructionNames[instruction];
+            literal.trailingComment = instructionNames.get(instruction);
             return literal;
         }
 
diff --git a/src/compiler/transformers/jsx.ts b/src/compiler/transformers/jsx.ts
index ecb5dd053e0..0f7a0eb7fba 100644
--- a/src/compiler/transformers/jsx.ts
+++ b/src/compiler/transformers/jsx.ts
@@ -229,7 +229,7 @@ namespace ts {
                     return String.fromCharCode(parseInt(hex, 16));
                 }
                 else {
-                    const ch = entities[word];
+                    const ch = entities.get(word);
                     // If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace)
                     return ch ? String.fromCharCode(ch) : match;
                 }
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index c900b7d20e1..2e926406fb4 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -10,12 +10,12 @@ namespace ts {
             importAliasNames: ParameterDeclaration[];
         }
 
-        const transformModuleDelegates = createMap<(node: SourceFile) => SourceFile>({
-            [ModuleKind.None]: transformCommonJSModule,
-            [ModuleKind.CommonJS]: transformCommonJSModule,
-            [ModuleKind.AMD]: transformAMDModule,
-            [ModuleKind.UMD]: transformUMDModule,
-        });
+        const transformModuleDelegates = createMapFromPairs<(node: SourceFile) => SourceFile>(
+            [ModuleKind.None, transformCommonJSModule],
+            [ModuleKind.CommonJS, transformCommonJSModule],
+            [ModuleKind.AMD, transformAMDModule],
+            [ModuleKind.UMD, transformUMDModule],
+        );
 
         const {
             startLexicalEnvironment,
@@ -60,10 +60,10 @@ namespace ts {
             }
 
             currentSourceFile = node;
-            currentModuleInfo = moduleInfoMap[getOriginalNodeId(node)] = collectExternalModuleInfo(node, resolver, compilerOptions);
+            currentModuleInfo = set(moduleInfoMap, getOriginalNodeId(node), collectExternalModuleInfo(node, resolver, compilerOptions));
 
             // Perform the transformation.
-            const transformModule = transformModuleDelegates[moduleKind] || transformModuleDelegates[ModuleKind.None];
+            const transformModule = transformModuleDelegates.get(moduleKind) || transformModuleDelegates.get(ModuleKind.None);
             const updated = transformModule(node);
 
             currentSourceFile = undefined;
@@ -444,7 +444,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfImportDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfImportDeclaration(statements, node);
@@ -523,7 +523,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfImportEqualsDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfImportEqualsDeclaration(statements, node);
@@ -610,7 +610,7 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
+                deferredExports.set(id, appendExportStatement(deferredExports.get(id), createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true));
             }
             else {
                 statements = appendExportStatement(statements, createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
@@ -651,7 +651,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -690,7 +690,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -741,7 +741,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfVariableStatement(statements, node);
@@ -794,7 +794,7 @@ namespace ts {
             // statement.
             if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === SyntaxKind.VariableStatement) {
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], <VariableStatement>node.original);
+                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), <VariableStatement>node.original));
             }
 
             return node;
@@ -820,9 +820,9 @@ namespace ts {
             // end of the transformed declaration. We use this marker to emit any deferred exports
             // of the declaration.
             const id = getOriginalNodeId(node);
-            const statements = deferredExports[id];
+            const statements = deferredExports.get(id);
             if (statements) {
-                delete deferredExports[id];
+                deferredExports.delete(id);
                 return append(statements, node);
             }
 
@@ -973,7 +973,7 @@ namespace ts {
          */
         function appendExportsOfDeclaration(statements: Statement[] | undefined, decl: Declaration): Statement[] | undefined {
             const name = getDeclarationName(decl);
-            const exportSpecifiers = currentModuleInfo.exportSpecifiers[name.text];
+            const exportSpecifiers = currentModuleInfo.exportSpecifiers.get(name.text);
             if (exportSpecifiers) {
                 for (const exportSpecifier of exportSpecifiers) {
                     statements = appendExportStatement(statements, exportSpecifier.name, name, /*location*/ exportSpecifier.name);
@@ -997,7 +997,7 @@ namespace ts {
         function appendExportStatement(statements: Statement[] | undefined, exportName: Identifier, expression: Expression, location?: TextRange, allowComments?: boolean): Statement[] | undefined {
             if (exportName.text === "default") {
                 const sourceFile = getOriginalNode(currentSourceFile, isSourceFile);
-                if (sourceFile && !sourceFile.symbol.exports["___esModule"]) {
+                if (sourceFile && !sourceFile.symbol.exports.get("___esModule")) {
                     if (languageVersion === ScriptTarget.ES3) {
                         statements = append(statements,
                             createStatement(
@@ -1102,7 +1102,7 @@ namespace ts {
         function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
             if (node.kind === SyntaxKind.SourceFile) {
                 currentSourceFile = <SourceFile>node;
-                currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
+                currentModuleInfo = moduleInfoMap.get(getOriginalNodeId(currentSourceFile));
                 noSubstitution = createMap<boolean>();
 
                 previousOnEmitNode(emitContext, node, emitCallback);
@@ -1128,7 +1128,7 @@ namespace ts {
          */
         function onSubstituteNode(emitContext: EmitContext, node: Node) {
             node = previousOnSubstituteNode(emitContext, node);
-            if (node.id && noSubstitution[node.id]) {
+            if (node.id && noSubstitution.get(node.id)) {
                 return node;
             }
 
@@ -1254,7 +1254,7 @@ namespace ts {
                     let expression: Expression = node;
                     for (const exportName of exportedNames) {
                         // Mark the node to prevent triggering this rule again.
-                        noSubstitution[getNodeId(expression)] = true;
+                        noSubstitution.set(getNodeId(expression), true);
                         expression = createExportExpression(exportName, expression, /*location*/ node);
                     }
 
@@ -1296,7 +1296,7 @@ namespace ts {
                         : node;
                     for (const exportName of exportedNames) {
                         // Mark the node to prevent triggering this rule again.
-                        noSubstitution[getNodeId(expression)] = true;
+                        noSubstitution.set(getNodeId(expression), true);
                         expression = createExportExpression(exportName, expression);
                     }
 
@@ -1318,7 +1318,7 @@ namespace ts {
                     || resolver.getReferencedValueDeclaration(name);
                 if (valueDeclaration) {
                     return currentModuleInfo
-                        && currentModuleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)];
+                        && currentModuleInfo.exportedBindings.get(getOriginalNodeId(valueDeclaration));
                 }
             }
         }
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 91e29e09886..8d1e1749c0b 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -73,11 +73,11 @@ namespace ts {
             // see comment to 'substitutePostfixUnaryExpression' for more details
 
             // Collect information about the external module and dependency groups.
-            moduleInfo = moduleInfoMap[id] = collectExternalModuleInfo(node, resolver, compilerOptions);
+            moduleInfo = set(moduleInfoMap, id, collectExternalModuleInfo(node, resolver, compilerOptions));
 
             // Make sure that the name of the 'exports' function does not conflict with
             // existing identifiers.
-            exportFunction = exportFunctionsMap[id] = createUniqueName("exports");
+            exportFunction = set(exportFunctionsMap, id, createUniqueName("exports"));
             contextObject = createUniqueName("context");
 
             // Add the body of the module.
@@ -121,7 +121,7 @@ namespace ts {
             }
 
             if (noSubstitution) {
-                noSubstitutionMap[id] = noSubstitution;
+                noSubstitutionMap.set(id, noSubstitution);
                 noSubstitution = undefined;
             }
 
@@ -147,13 +147,13 @@ namespace ts {
                 const externalImport = externalImports[i];
                 const externalModuleName = getExternalModuleNameLiteral(externalImport, currentSourceFile, host, resolver, compilerOptions);
                 const text = externalModuleName.text;
-                if (hasProperty(groupIndices, text)) {
+                const groupIndex = groupIndices.get(text);
+                if (groupIndex !== undefined) {
                     // deduplicate/group entries in dependency list by the dependency name
-                    const groupIndex = groupIndices[text];
                     dependencyGroups[groupIndex].externalImports.push(externalImport);
                 }
                 else {
-                    groupIndices[text] = dependencyGroups.length;
+                    groupIndices.set(text, dependencyGroups.length);
                     dependencyGroups.push({
                         name: externalModuleName,
                         externalImports: [externalImport]
@@ -305,7 +305,7 @@ namespace ts {
             // this set is used to filter names brought by star expors.
 
             // local names set should only be added if we have anything exported
-            if (!moduleInfo.exportedNames && isEmpty(moduleInfo.exportSpecifiers)) {
+            if (!moduleInfo.exportedNames && mapIsEmpty(moduleInfo.exportSpecifiers)) {
                 // no exported declarations (export var ...) or export specifiers (export {x})
                 // check if we have any non star export declarations.
                 let hasExportDeclarationWithExportClause = false;
@@ -608,7 +608,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfImportDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfImportDeclaration(statements, node);
@@ -631,7 +631,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfImportEqualsDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfImportEqualsDeclaration(statements, node);
@@ -656,7 +656,7 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), expression, /*allowComments*/ true);
+                deferredExports.set(id, appendExportStatement(deferredExports.get(id), createIdentifier("default"), expression, /*allowComments*/ true));
             }
             else {
                 return createExportStatement(createIdentifier("default"), expression, /*allowComments*/ true);
@@ -688,7 +688,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
             }
             else {
                 hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node);
@@ -730,7 +730,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
+                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -770,7 +770,7 @@ namespace ts {
             if (isMarkedDeclaration) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration);
+                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), node, isExportedDeclaration));
             }
             else {
                 statements = appendExportsOfVariableStatement(statements, node, /*exportSelf*/ false);
@@ -883,7 +883,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === SyntaxKind.VariableStatement) {
                 const id = getOriginalNodeId(node);
                 const isExportedDeclaration = hasModifier(node.original, ModifierFlags.Export);
-                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], <VariableStatement>node.original, isExportedDeclaration);
+                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), <VariableStatement>node.original, isExportedDeclaration));
             }
 
             return node;
@@ -909,9 +909,9 @@ namespace ts {
             // end of the transformed declaration. We use this marker to emit any deferred exports
             // of the declaration.
             const id = getOriginalNodeId(node);
-            const statements = deferredExports[id];
+            const statements = deferredExports.get(id);
             if (statements) {
-                delete deferredExports[id];
+                deferredExports.delete(id);
                 return append(statements, node);
             }
 
@@ -1080,7 +1080,7 @@ namespace ts {
             }
 
             const name = getDeclarationName(decl);
-            const exportSpecifiers = moduleInfo.exportSpecifiers[name.text];
+            const exportSpecifiers = moduleInfo.exportSpecifiers.get(name.text);
             if (exportSpecifiers) {
                 for (const exportSpecifier of exportSpecifiers) {
                     if (exportSpecifier.name.text !== excludeName) {
@@ -1554,12 +1554,12 @@ namespace ts {
             if (node.kind === SyntaxKind.SourceFile) {
                 const id = getOriginalNodeId(node);
                 currentSourceFile = <SourceFile>node;
-                moduleInfo = moduleInfoMap[id];
-                exportFunction = exportFunctionsMap[id];
-                noSubstitution = noSubstitutionMap[id];
+                moduleInfo = moduleInfoMap.get(id);
+                exportFunction = exportFunctionsMap.get(id);
+                noSubstitution = noSubstitutionMap.get(id);
 
                 if (noSubstitution) {
-                    delete noSubstitutionMap[id];
+                    noSubstitutionMap.delete(id);
                 }
 
                 previousOnEmitNode(emitContext, node, emitCallback);
@@ -1756,7 +1756,7 @@ namespace ts {
                         exportedNames = append(exportedNames, getDeclarationName(valueDeclaration));
                     }
 
-                    exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)]);
+                    exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings.get(getOriginalNodeId(valueDeclaration)));
                 }
             }
 
@@ -1770,7 +1770,7 @@ namespace ts {
          */
         function preventSubstitution<T extends Node>(node: T): T {
             if (noSubstitution === undefined) noSubstitution = createMap<boolean>();
-            noSubstitution[getNodeId(node)] = true;
+            noSubstitution.set(getNodeId(node), true);
             return node;
         }
 
@@ -1780,7 +1780,7 @@ namespace ts {
          * @param node The node to test.
          */
         function isSubstitutionPrevented(node: Node) {
-            return noSubstitution && node.id && noSubstitution[node.id];
+            return noSubstitution && node.id && noSubstitution.get(node.id);
         }
     }
 }
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 77af854269e..4b0f981f27c 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -752,7 +752,7 @@ namespace ts {
                 if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
                     // record an alias as the class name is not in scope for statics.
                     enableSubstitutionForClassAliases();
-                    classAliases[getOriginalNodeId(node)] = getSynthesizedClone(temp);
+                    classAliases.set(getOriginalNodeId(node), getSynthesizedClone(temp));
                 }
 
                 // To preserve the behavior of the old emitter, we explicitly indent
@@ -1420,7 +1420,7 @@ namespace ts {
                 return undefined;
             }
 
-            const classAlias = classAliases && classAliases[getOriginalNodeId(node)];
+            const classAlias = classAliases && classAliases.get(getOriginalNodeId(node));
             const localName = getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true);
             const decorate = createDecorateHelper(context, decoratorExpressions, localName);
             const expression = createAssignment(localName, classAlias ? createAssignment(classAlias, decorate) : decorate);
@@ -2530,8 +2530,8 @@ namespace ts {
                     currentScopeFirstDeclarationsOfName = createMap<Node>();
                 }
 
-                if (!(name in currentScopeFirstDeclarationsOfName)) {
-                    currentScopeFirstDeclarationsOfName[name] = node;
+                if (!currentScopeFirstDeclarationsOfName.has(name)) {
+                    currentScopeFirstDeclarationsOfName.set(name, node);
                 }
             }
         }
@@ -2544,7 +2544,7 @@ namespace ts {
             if (currentScopeFirstDeclarationsOfName) {
                 const name = node.symbol && node.symbol.name;
                 if (name) {
-                    return currentScopeFirstDeclarationsOfName[name] === node;
+                    return currentScopeFirstDeclarationsOfName.get(name) === node;
                 }
             }
 
@@ -3085,7 +3085,7 @@ namespace ts {
             if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
                 enableSubstitutionForClassAliases();
                 const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
-                classAliases[getOriginalNodeId(node)] = classAlias;
+                classAliases.set(getOriginalNodeId(node), classAlias);
                 hoistVariableDeclaration(classAlias);
                 return classAlias;
             }
@@ -3230,7 +3230,7 @@ namespace ts {
                     // constructor references in static property initializers.
                     const declaration = resolver.getReferencedValueDeclaration(node);
                     if (declaration) {
-                        const classAlias = classAliases[declaration.id];
+                        const classAlias = classAliases.get(declaration.id);
                         if (classAlias) {
                             const clone = getSynthesizedClone(classAlias);
                             setSourceMapRange(clone, node);
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index a7304eebe4b..0e66ccb14b8 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -67,11 +67,11 @@ namespace ts {
     const gutterSeparator = " ";
     const resetEscapeSequence = "\u001b[0m";
     const ellipsis = "...";
-    const categoryFormatMap = createMap<string>({
-        [DiagnosticCategory.Warning]: yellowForegroundEscapeSequence,
-        [DiagnosticCategory.Error]: redForegroundEscapeSequence,
-        [DiagnosticCategory.Message]: blueForegroundEscapeSequence,
-    });
+    const categoryFormatMap = createMapFromPairs<string>(
+        [DiagnosticCategory.Warning, yellowForegroundEscapeSequence],
+        [DiagnosticCategory.Error, redForegroundEscapeSequence],
+        [DiagnosticCategory.Message, blueForegroundEscapeSequence],
+    );
 
     function formatAndReset(text: string, formatStyle: string) {
         return formatStyle + text + resetEscapeSequence;
@@ -139,7 +139,7 @@ namespace ts {
             output += `${ relativeFileName }(${ firstLine + 1 },${ firstLineChar + 1 }): `;
         }
 
-        const categoryColor = categoryFormatMap[diagnostic.category];
+        const categoryColor = categoryFormatMap.get(diagnostic.category);
         const category = DiagnosticCategory[diagnostic.category].toLowerCase();
         output += `${ formatAndReset(category, categoryColor) } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }`;
         output += sys.newLine + sys.newLine;
@@ -378,9 +378,8 @@ namespace ts {
         }
 
         function cachedFileExists(fileName: string): boolean {
-            return fileName in cachedExistingFiles
-                ? cachedExistingFiles[fileName]
-                : cachedExistingFiles[fileName] = hostFileExists(fileName);
+            const fileExists = cachedExistingFiles.get(fileName);
+            return fileExists !== undefined ? fileExists : set(cachedExistingFiles, fileName, hostFileExists(fileName));
         }
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
@@ -674,13 +673,9 @@ namespace ts {
 
             if (option.name === "lib") {
                 description = getDiagnosticText(option.description);
-                const options: string[] = [];
                 const element = (<CommandLineOptionOfListType>option).element;
                 const typeMap = <Map<number | string>>element.type;
-                for (const key in typeMap) {
-                    options.push(`'${key}'`);
-                }
-                optionsDescriptionMap[description] = options;
+                optionsDescriptionMap.set(description, keysOfMap(typeMap).map(key => `'${key}'`));
             }
             else {
                 description = getDiagnosticText(option.description);
@@ -702,7 +697,7 @@ namespace ts {
         for (let i = 0; i < usageColumn.length; i++) {
             const usage = usageColumn[i];
             const description = descriptionColumn[i];
-            const kindsList = optionsDescriptionMap[description];
+            const kindsList = optionsDescriptionMap.get(description);
             output.push(usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine);
 
             if (kindsList) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index c1592d30eae..055049999ec 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1,11 +1,25 @@
 namespace ts {
-
+    /**
+     * Type of objects whose values are all of the same type.
+     * The `in` and `for-in` operators can *not* be safely used,
+     * since `Object.prototype` may be modified by outside code.
+     */
     export interface MapLike<T> {
         [index: string]: T;
     }
 
-    export interface Map<T> extends MapLike<T> {
-        __mapBrand: any;
+    /** It's allowed to get/set into a map with numbers. However, when iterating, you may get strings back due to the shim being an ordinary object (which only allows string keys). */
+    export type MapKey = string | number;
+
+    /** Minimal ES6 Map interface. */
+    export interface Map<T> {
+        get(key: MapKey): T;
+        has(key: MapKey): boolean;
+        set(key: MapKey, value: T): this;
+        delete(key: MapKey): boolean;
+        clear(): void;
+        /** `key` may *not* be a string if it was set with a number and we are not using the shim. */
+        forEach(action: (value: T, key: string) => void): void;
     }
 
     // branded string type used to store absolute, normalized and canonicalized paths
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 3dd7054a405..94b0fa20987 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -70,11 +70,11 @@ namespace ts {
     }
 
     export function hasResolvedModule(sourceFile: SourceFile, moduleNameText: string): boolean {
-        return !!(sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules[moduleNameText]);
+        return !!(sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText));
     }
 
     export function getResolvedModule(sourceFile: SourceFile, moduleNameText: string): ResolvedModuleFull {
-        return hasResolvedModule(sourceFile, moduleNameText) ? sourceFile.resolvedModules[moduleNameText] : undefined;
+        return hasResolvedModule(sourceFile, moduleNameText) ? sourceFile.resolvedModules.get(moduleNameText) : undefined;
     }
 
     export function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModuleFull): void {
@@ -82,7 +82,7 @@ namespace ts {
             sourceFile.resolvedModules = createMap<ResolvedModuleFull>();
         }
 
-        sourceFile.resolvedModules[moduleNameText] = resolvedModule;
+        sourceFile.resolvedModules.set(moduleNameText, resolvedModule);
     }
 
     export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective): void {
@@ -90,7 +90,7 @@ namespace ts {
             sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();
         }
 
-        sourceFile.resolvedTypeReferenceDirectiveNames[typeReferenceDirectiveName] = resolvedTypeReferenceDirective;
+        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective);
     }
 
     /* @internal */
@@ -112,7 +112,7 @@ namespace ts {
         }
         for (let i = 0; i < names.length; i++) {
             const newResolution = newResolutions[i];
-            const oldResolution = oldResolutions && oldResolutions[names[i]];
+            const oldResolution = oldResolutions && oldResolutions.get(names[i]);
             const changed =
                 oldResolution
                     ? !newResolution || !comparer(oldResolution, newResolution)
@@ -2217,22 +2217,16 @@ namespace ts {
         }
 
         function reattachFileDiagnostics(newFile: SourceFile): void {
-            if (!hasProperty(fileDiagnostics, newFile.fileName)) {
-                return;
-            }
-
-            for (const diagnostic of fileDiagnostics[newFile.fileName]) {
-                diagnostic.file = newFile;
-            }
+            forEach(fileDiagnostics.get(newFile.fileName), diagnostic => diagnostic.file = newFile);
         }
 
         function add(diagnostic: Diagnostic): void {
             let diagnostics: Diagnostic[];
             if (diagnostic.file) {
-                diagnostics = fileDiagnostics[diagnostic.file.fileName];
+                diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
                 if (!diagnostics) {
                     diagnostics = [];
-                    fileDiagnostics[diagnostic.file.fileName] = diagnostics;
+                    fileDiagnostics.set(diagnostic.file.fileName, diagnostics);
                 }
             }
             else {
@@ -2252,7 +2246,7 @@ namespace ts {
         function getDiagnostics(fileName?: string): Diagnostic[] {
             sortAndDeduplicate();
             if (fileName) {
-                return fileDiagnostics[fileName] || [];
+                return fileDiagnostics.get(fileName) || [];
             }
 
             const allDiagnostics: Diagnostic[] = [];
@@ -2262,9 +2256,9 @@ namespace ts {
 
             forEach(nonFileDiagnostics, pushDiagnostic);
 
-            for (const key in fileDiagnostics) {
-                forEach(fileDiagnostics[key], pushDiagnostic);
-            }
+            fileDiagnostics.forEach(diagnostics => {
+                forEach(diagnostics, pushDiagnostic);
+            });
 
             return sortAndDeduplicateDiagnostics(allDiagnostics);
         }
@@ -2277,9 +2271,9 @@ namespace ts {
             diagnosticsModified = false;
             nonFileDiagnostics = sortAndDeduplicateDiagnostics(nonFileDiagnostics);
 
-            for (const key in fileDiagnostics) {
-                fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
-            }
+            fileDiagnostics.forEach((diagnostics, key) => {
+                fileDiagnostics.set(key, sortAndDeduplicateDiagnostics(diagnostics));
+            });
         }
     }
 
@@ -2316,7 +2310,7 @@ namespace ts {
         return s;
 
         function getReplacement(c: string) {
-            return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
+            return escapedCharsMap.get(c) || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
         }
     }
 
@@ -3322,13 +3316,14 @@ namespace ts {
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
         if (syntaxKindEnum) {
-            if (syntaxKindCache[kind]) {
-                return syntaxKindCache[kind];
+            const cached = syntaxKindCache.get(kind);
+            if (cached !== undefined) {
+                return cached;
             }
 
             for (const name in syntaxKindEnum) {
                 if (syntaxKindEnum[name] === kind) {
-                    return syntaxKindCache[kind] = kind.toString() + " (" + name + ")";
+                    return set(syntaxKindCache, kind, kind.toString() + " (" + name + ")");
                 }
             }
         }
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 43e01ca56bb..c9ea2af1a87 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -46,54 +46,54 @@ namespace ts {
      *       supplant the existing `forEachChild` implementation if performance is not
      *       significantly impacted.
      */
-    const nodeEdgeTraversalMap = createMap<NodeTraversalPath>({
-        [SyntaxKind.QualifiedName]: [
+    const nodeEdgeTraversalMap = createMapFromPairs<NodeTraversalPath>(
+        [SyntaxKind.QualifiedName, [
             { name: "left", test: isEntityName },
             { name: "right", test: isIdentifier }
-        ],
-        [SyntaxKind.Decorator]: [
+        ]],
+        [SyntaxKind.Decorator, [
             { name: "expression", test: isLeftHandSideExpression }
-        ],
-        [SyntaxKind.TypeAssertionExpression]: [
+        ]],
+        [SyntaxKind.TypeAssertionExpression, [
             { name: "type", test: isTypeNode },
             { name: "expression", test: isUnaryExpression }
-        ],
-        [SyntaxKind.AsExpression]: [
+        ]],
+        [SyntaxKind.AsExpression, [
             { name: "expression", test: isExpression },
             { name: "type", test: isTypeNode }
-        ],
-        [SyntaxKind.NonNullExpression]: [
+        ]],
+        [SyntaxKind.NonNullExpression, [
             { name: "expression", test: isLeftHandSideExpression }
-        ],
-        [SyntaxKind.EnumDeclaration]: [
+        ]],
+        [SyntaxKind.EnumDeclaration, [
             { name: "decorators", test: isDecorator },
             { name: "modifiers", test: isModifier },
             { name: "name", test: isIdentifier },
             { name: "members", test: isEnumMember }
-        ],
-        [SyntaxKind.ModuleDeclaration]: [
+        ]],
+        [SyntaxKind.ModuleDeclaration, [
             { name: "decorators", test: isDecorator },
             { name: "modifiers", test: isModifier },
             { name: "name", test: isModuleName },
             { name: "body", test: isModuleBody }
-        ],
-        [SyntaxKind.ModuleBlock]: [
+        ]],
+        [SyntaxKind.ModuleBlock, [
             { name: "statements", test: isStatement }
-        ],
-        [SyntaxKind.ImportEqualsDeclaration]: [
+        ]],
+        [SyntaxKind.ImportEqualsDeclaration, [
             { name: "decorators", test: isDecorator },
             { name: "modifiers", test: isModifier },
             { name: "name", test: isIdentifier },
             { name: "moduleReference", test: isModuleReference }
-        ],
-        [SyntaxKind.ExternalModuleReference]: [
+        ]],
+        [SyntaxKind.ExternalModuleReference, [
             { name: "expression", test: isExpression, optional: true }
-        ],
-        [SyntaxKind.EnumMember]: [
+        ]],
+        [SyntaxKind.EnumMember, [
             { name: "name", test: isPropertyName },
             { name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
-        ]
-    });
+        ]]
+    );
 
     function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
         return node ? f(initial, node) : initial;
@@ -530,7 +530,7 @@ namespace ts {
                 break;
 
             default:
-                const edgeTraversalPath = nodeEdgeTraversalMap[kind];
+                const edgeTraversalPath = nodeEdgeTraversalMap.get(kind);
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
                         const value = (<MapLike<any>>node)[edge.name];
@@ -1188,10 +1188,10 @@ namespace ts {
 
             default:
                 let updated: Node & MapLike<any>;
-                const edgeTraversalPath = nodeEdgeTraversalMap[kind];
+                const edgeTraversalPath = nodeEdgeTraversalMap.get(kind);
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
-                        const value = <Node | NodeArray<Node>>(<Node & Map<any>>node)[edge.name];
+                        const value = <Node | NodeArray<Node>>(<Node & MapLike<any>>node)[edge.name];
                         if (value !== undefined) {
                             const visited = isArray(value)
                                 ? visitNodes(value, visitor, edge.test, 0, value.length, edge.parenthesize, node)
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 7c7a06db0b6..d4d6056f320 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -96,7 +96,7 @@ namespace FourSlash {
     });
 
     export function escapeXmlAttributeValue(s: string) {
-        return s.replace(/[&<>"'\/]/g, ch => entityMap[ch]);
+        return s.replace(/[&<>"'\/]/g, ch => entityMap.get(ch));
     }
 
     // Name of testcase metadata including ts.CompilerOptions properties that will be used by globalOptions
@@ -222,7 +222,7 @@ namespace FourSlash {
             }
 
             function tryAdd(path: string) {
-                const inputFile = inputFiles[path];
+                const inputFile = inputFiles.get(path);
                 if (inputFile && !Harness.isDefaultLibraryFile(path)) {
                     languageServiceAdapterHost.addScript(path, inputFile, /*isRootFile*/ true);
                     return true;
@@ -256,7 +256,7 @@ namespace FourSlash {
 
             ts.forEach(testData.files, file => {
                 // Create map between fileName and its content for easily looking up when resolveReference flag is specified
-                this.inputFiles[file.fileName] = file.content;
+                this.inputFiles.set(file.fileName, file.content);
 
                 if (ts.getBaseFileName(file.fileName).toLowerCase() === "tsconfig.json") {
                     const configJson = ts.parseConfigFileTextToJson(file.fileName, file.content);
@@ -322,11 +322,11 @@ namespace FourSlash {
             }
             else {
                 // resolveReference file-option is not specified then do not resolve any files and include all inputFiles
-                for (const fileName in this.inputFiles) {
+                this.inputFiles.forEach((file, fileName) => {
                     if (!Harness.isDefaultLibraryFile(fileName)) {
-                        this.languageServiceAdapterHost.addScript(fileName, this.inputFiles[fileName], /*isRootFile*/ true);
+                        this.languageServiceAdapterHost.addScript(fileName, file, /*isRootFile*/ true);
                     }
-                }
+                });
                 this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,
                     Harness.Compiler.getDefaultLibrarySourceFile().text, /*isRootFile*/ false);
             }
@@ -659,11 +659,12 @@ namespace FourSlash {
             const completions = this.getCompletionListAtCaret();
             const uniqueItems = ts.createMap<string>();
             for (const item of completions.entries) {
-                if (!(item.name in uniqueItems)) {
-                    uniqueItems[item.name] = item.kind;
+                const uniqueItem = uniqueItems.get(item.name);
+                if (!uniqueItem) {
+                    uniqueItems.set(item.name, item.kind);
                 }
                 else {
-                    assert.equal(item.kind, uniqueItems[item.name], `Items should have the same kind, got ${item.kind} and ${uniqueItems[item.name]}`);
+                    assert.equal(item.kind, uniqueItem, `Items should have the same kind, got ${item.kind} and ${uniqueItem}`);
                 }
             }
         }
@@ -831,7 +832,7 @@ namespace FourSlash {
         }
 
         public verifyRangesWithSameTextReferenceEachOther() {
-            ts.forEachProperty(this.rangesByText(), ranges => this.verifyRangesReferenceEachOther(ranges));
+            this.rangesByText().forEach(ranges => this.verifyRangesReferenceEachOther(ranges));
         }
 
         public verifyDisplayPartsOfReferencedSymbol(expected: ts.SymbolDisplayPart[]) {
@@ -903,7 +904,8 @@ namespace FourSlash {
         }
 
         public verifyQuickInfos(namesAndTexts: { [name: string]: string | [string, string] }) {
-            ts.forEachProperty(ts.createMap(namesAndTexts), (text, name) => {
+            for (const name in namesAndTexts) if (ts.hasProperty(namesAndTexts, name)) {
+                const text = namesAndTexts[name];
                 if (text instanceof Array) {
                     assert(text.length === 2);
                     const [expectedText, expectedDocumentation] = text;
@@ -912,7 +914,7 @@ namespace FourSlash {
                 else {
                     this.verifyQuickInfoAt(name, text);
                 }
-            });
+            }
         }
 
         public verifyQuickInfoString(expectedText: string, expectedDocumentation?: string) {
@@ -2087,7 +2089,7 @@ namespace FourSlash {
                 "<": ts.CharacterCodes.lessThan
             });
 
-            const charCode = openBraceMap[openingBrace];
+            const charCode = openBraceMap.get(openingBrace);
 
             if (!charCode) {
                 this.raiseError(`Invalid openingBrace '${openingBrace}' specified.`);
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 26a4a6f963d..265fe4c142c 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -918,10 +918,9 @@ namespace Harness {
                 return undefined;
             }
 
-            if (!libFileNameSourceFileMap[fileName]) {
-                libFileNameSourceFileMap[fileName] = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest);
-            }
-            return libFileNameSourceFileMap[fileName];
+            const sourceFile = libFileNameSourceFileMap.get(fileName);
+            return sourceFile || ts.set(libFileNameSourceFileMap, fileName,
+                createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest));
         }
 
         export function getDefaultLibFileName(options: ts.CompilerOptions): string {
@@ -1103,10 +1102,10 @@ namespace Harness {
                 optionsIndex = ts.createMap<ts.CommandLineOption>();
                 const optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
                 for (const option of optionDeclarations) {
-                    optionsIndex[option.name.toLowerCase()] = option;
+                    optionsIndex.set(option.name.toLowerCase(), option);
                 }
             }
-            return optionsIndex[name.toLowerCase()];
+            return optionsIndex.get(name.toLowerCase());
         }
 
         export function setCompilerOptionsFromHarnessSetting(settings: Harness.TestCaseParser.CompilerSettings, options: ts.CompilerOptions & HarnessOptions): void {
@@ -1466,7 +1465,7 @@ namespace Harness {
             const fullResults = ts.createMap<TypeWriterResult[]>();
 
             for (const sourceFile of allFiles) {
-                fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
+                fullResults.set(sourceFile.unitName, fullWalker.getTypeAndSymbols(sourceFile.unitName));
             }
 
             // Produce baselines.  The first gives the types for all expressions.
@@ -1519,7 +1518,7 @@ namespace Harness {
 
                 allFiles.forEach(file => {
                     const codeLines = file.content.split("\n");
-                    typeWriterResults[file.unitName].forEach(result => {
+                    typeWriterResults.get(file.unitName).forEach(result => {
                         if (isSymbolBaseline && !result.symbol) {
                             return;
                         }
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index a49f8926729..2ddc38499d0 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -262,7 +262,7 @@ namespace Harness.LanguageService {
                 this.getModuleResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
                     const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
-                    const imports = ts.createMap<string>();
+                    const imports = ts.createMapLike<string>();
                     for (const module of preprocessInfo.importedFiles) {
                         const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
                         if (resolutionInfo.resolvedModule) {
@@ -275,7 +275,7 @@ namespace Harness.LanguageService {
                     const scriptInfo = this.getScriptInfo(fileName);
                     if (scriptInfo) {
                         const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
-                        const resolutions = ts.createMap<ts.ResolvedTypeReferenceDirective>();
+                        const resolutions = ts.createMapLike<ts.ResolvedTypeReferenceDirective>();
                         const settings = this.nativeHost.getCompilationSettings();
                         for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {
                             const resolutionInfo = ts.resolveTypeReferenceDirective(typeReferenceDirective.fileName, fileName, settings, moduleResolutionHost);
diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts
index f7541dc9bfe..f1cc992c4a7 100644
--- a/src/harness/projectsRunner.ts
+++ b/src/harness/projectsRunner.ts
@@ -256,17 +256,20 @@ class ProjectRunner extends RunnerBase {
                 // Set the values specified using json
                 const optionNameMap = ts.arrayToMap(ts.optionDeclarations, option => option.name);
                 for (const name in testCase) {
-                    if (name !== "mapRoot" && name !== "sourceRoot" && name in optionNameMap) {
-                        const option = optionNameMap[name];
-                        const optType = option.type;
-                        let value = <any>testCase[name];
-                        if (typeof optType !== "string") {
-                            const key = value.toLowerCase();
-                            if (key in optType) {
-                                value = optType[key];
+                    if (name !== "mapRoot" && name !== "sourceRoot") {
+                        const option = optionNameMap.get(name);
+                        if (option) {
+                            const optType = option.type;
+                            let value = <any>testCase[name];
+                            if (typeof optType !== "string") {
+                                const key = value.toLowerCase();
+                                const optTypeValue = optType.get(key);
+                                if (optTypeValue) {
+                                    value = optTypeValue;
+                                }
                             }
+                            compilerOptions[option.name] = value;
                         }
-                        compilerOptions[option.name] = value;
                     }
                 }
 
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index 4286d3555d8..b6a90f53259 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -8,25 +8,28 @@ namespace ts {
 
     function createDefaultServerHost(fileMap: Map<File>): server.ServerHost {
         const existingDirectories = createMap<boolean>();
-        for (const name in fileMap) {
+        forEachKeyInMap(fileMap, name => {
             let dir = getDirectoryPath(name);
             let previous: string;
             do {
-                existingDirectories[dir] = true;
+                existingDirectories.set(dir, true);
                 previous = dir;
                 dir = getDirectoryPath(dir);
             } while (dir !== previous);
-        }
+        });
         return {
             args: <string[]>[],
             newLine: "\r\n",
             useCaseSensitiveFileNames: false,
             write: noop,
-            readFile: path => path in fileMap ? fileMap[path].content : undefined,
+            readFile: path => {
+                const file = fileMap.get(path);
+                return file && file.content;
+            },
             writeFile: notImplemented,
             resolvePath: notImplemented,
-            fileExists: path => path in fileMap,
-            directoryExists: path => existingDirectories[path] || false,
+            fileExists: path => fileMap.has(path),
+            directoryExists: path => existingDirectories.get(path) || false,
             createDirectory: noop,
             getExecutingFilePath: () => "",
             getCurrentDirectory: () => "",
@@ -191,7 +194,7 @@ namespace ts {
             assert.isTrue(typeof diags[0].messageText === "string" && ((<string>diags[0].messageText).indexOf("Cannot find module") === 0), "should be 'cannot find module' message");
 
             // assert that import will success once file appear on disk
-            fileMap[imported.name] = imported;
+            fileMap.set(imported.name, imported);
             fileExistsCalledForBar = false;
             rootScriptInfo.editContent(0, root.content.length, `import {y} from "bar"`);
 
diff --git a/src/harness/unittests/moduleResolution.ts b/src/harness/unittests/moduleResolution.ts
index 35313e15308..8e4ace38655 100644
--- a/src/harness/unittests/moduleResolution.ts
+++ b/src/harness/unittests/moduleResolution.ts
@@ -36,7 +36,7 @@ namespace ts {
             for (const f of files) {
                 let name = getDirectoryPath(f.name);
                 while (true) {
-                    directories[name] = name;
+                    directories.set(name, name);
                     const baseName = getDirectoryPath(name);
                     if (baseName === name) {
                         break;
@@ -46,20 +46,19 @@ namespace ts {
             }
             return {
                 readFile,
-                directoryExists: path => {
-                    return path in directories;
-                },
+                directoryExists: path => directories.has(path),
                 fileExists: path => {
-                    assert.isTrue(getDirectoryPath(path) in directories, `'fileExists' '${path}' request in non-existing directory`);
-                    return path in map;
+                    assert.isTrue(directories.has(getDirectoryPath(path)), `'fileExists' '${path}' request in non-existing directory`);
+                    return map.has(path);
                 }
             };
         }
         else {
-            return { readFile, fileExists: path => path in map, };
+            return { readFile, fileExists: path => map.has(path) };
         }
         function readFile(path: string): string {
-            return path in map ? map[path].content : undefined;
+            const file = map.get(path);
+            return file && file.content;
         }
     }
 
@@ -300,7 +299,8 @@ namespace ts {
             const host: CompilerHost = {
                 getSourceFile: (fileName: string, languageVersion: ScriptTarget) => {
                     const path = normalizePath(combinePaths(currentDirectory, fileName));
-                    return path in files ? createSourceFile(fileName, files[path], languageVersion) : undefined;
+                    const file = files.get(path);
+                    return file && createSourceFile(fileName, file, languageVersion);
                 },
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile: notImplemented,
@@ -311,7 +311,7 @@ namespace ts {
                 useCaseSensitiveFileNames: () => false,
                 fileExists: fileName => {
                     const path = normalizePath(combinePaths(currentDirectory, fileName));
-                    return path in files;
+                    return files.has(path);
                 },
                 readFile: notImplemented
             };
@@ -371,7 +371,11 @@ export = C;
         function test(files: Map<string>, options: CompilerOptions, currentDirectory: string, useCaseSensitiveFileNames: boolean, rootFiles: string[], diagnosticCodes: number[]): void {
             const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
             if (!useCaseSensitiveFileNames) {
-                files = reduceProperties(files, (files, file, fileName) => (files[getCanonicalFileName(fileName)] = file, files), createMap<string>());
+                const oldFiles = files;
+                files = createMap<string>();
+                oldFiles.forEach((file, fileName) => {
+                    files.set(getCanonicalFileName(fileName), file);
+                });
             }
 
             const host: CompilerHost = {
@@ -380,7 +384,8 @@ export = C;
                         return library;
                     }
                     const path = getCanonicalFileName(normalizePath(combinePaths(currentDirectory, fileName)));
-                    return path in files ? createSourceFile(fileName, files[path], languageVersion) : undefined;
+                    const file = files.get(path);
+                    return file && createSourceFile(fileName, file, languageVersion);
                 },
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile: notImplemented,
@@ -391,7 +396,7 @@ export = C;
                 useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
                 fileExists: fileName => {
                     const path = getCanonicalFileName(normalizePath(combinePaths(currentDirectory, fileName)));
-                    return path in files;
+                    return files.has(path);
                 },
                 readFile: notImplemented
             };
@@ -1020,8 +1025,8 @@ import b = require("./moduleB");
             const names = map(files, f => f.name);
             const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES2015)), f => f.fileName);
             const compilerHost: CompilerHost = {
-                fileExists : fileName => fileName in sourceFiles,
-                getSourceFile: fileName => sourceFiles[fileName],
+                fileExists : fileName => sourceFiles.has(fileName),
+                getSourceFile: fileName => sourceFiles.get(fileName),
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile: notImplemented,
                 getCurrentDirectory: () => "/",
@@ -1029,7 +1034,10 @@ import b = require("./moduleB");
                 getCanonicalFileName: f => f.toLowerCase(),
                 getNewLine: () => "\r\n",
                 useCaseSensitiveFileNames: () => false,
-                readFile: fileName => fileName in sourceFiles ? sourceFiles[fileName].text : undefined
+                readFile: fileName => {
+                    const file = sourceFiles.get(fileName);
+                    return file && file.text;
+                }
             };
             const program1 = createProgram(names, {}, compilerHost);
             const diagnostics1 = program1.getFileProcessingDiagnostics().getDiagnostics();
diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts
index 6dbd74e71d2..54c05a9c383 100644
--- a/src/harness/unittests/reuseProgramStructure.ts
+++ b/src/harness/unittests/reuseProgramStructure.ts
@@ -122,7 +122,7 @@ namespace ts {
             trace: s => trace.push(s),
             getTrace: () => trace,
             getSourceFile(fileName): SourceFile {
-                return files[fileName];
+                return files.get(fileName);
             },
             getDefaultLibFileName(): string {
                 return "lib.d.ts";
@@ -143,9 +143,10 @@ namespace ts {
             getNewLine(): string {
                 return sys ? sys.newLine : newLine;
             },
-            fileExists: fileName => fileName in files,
+            fileExists: fileName => files.has(fileName),
             readFile: fileName => {
-                return fileName in files ? files[fileName].text : undefined;
+                const file = files.get(fileName);
+                return file && file.text;
             },
         };
     }
@@ -188,7 +189,7 @@ namespace ts {
         }
         else {
             assert.isTrue(cache !== undefined, `expected ${caption} to be set`);
-            assert.isTrue(equalOwnProperties(expectedContent, cache, entryChecker), `contents of ${caption} did not match the expected contents.`);
+            assert.isTrue(mapsAreEqual(expectedContent, cache, entryChecker), `contents of ${caption} did not match the expected contents.`);
         }
     }
 
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index 8800e84474b..da24fe1606b 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -422,9 +422,10 @@ namespace ts.server {
             handle(msg: protocol.Message): void {
                 if (msg.type === "response") {
                     const response = <protocol.Response>msg;
-                    if (response.request_seq in this.callbacks) {
-                        this.callbacks[response.request_seq](response);
-                        delete this.callbacks[response.request_seq];
+                    const handler = this.callbacks.get(response.request_seq);
+                    if (handler) {
+                        handler(response);
+                        this.callbacks.delete(response.request_seq);
                     }
                 }
                 else if (msg.type === "event") {
@@ -434,13 +435,14 @@ namespace ts.server {
             }
 
             emit(name: string, args: any): void {
-                if (name in this.eventHandlers) {
-                    this.eventHandlers[name](args);
+                const handler = this.eventHandlers.get(name);
+                if (handler) {
+                    handler(args);
                 }
             }
 
             on(name: string, handler: (args: any) => void): void {
-                this.eventHandlers[name] = handler;
+                this.eventHandlers.set(name, handler);
             }
 
             connect(session: InProcSession): void {
@@ -458,7 +460,7 @@ namespace ts.server {
                     command,
                     arguments: args
                 });
-                this.callbacks[this.seq] = callback;
+                this.callbacks.set(this.seq, callback);
             }
         };
 
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 77ebee6fadd..bec3a700879 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -243,12 +243,18 @@ namespace ts.projectSystem {
     }
 
     export function checkMapKeys(caption: string, map: Map<any>, expectedKeys: string[]) {
-        assert.equal(reduceProperties(map, count => count + 1, 0), expectedKeys.length, `${caption}: incorrect size of map`);
+        assert.equal(mapSize(map), expectedKeys.length, `${caption}: incorrect size of map`);
         for (const name of expectedKeys) {
-            assert.isTrue(name in map, `${caption} is expected to contain ${name}, actual keys: ${Object.keys(map)}`);
+            assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${keysOfMap(map)}`);
         }
     }
 
+    function mapSize<T>(map: Map<T>): number {
+        let size = 0;
+        map.forEach(() => { size++; });
+        return size;
+    }
+
     export function checkFileNames(caption: string, actualFileNames: string[], expectedFileNames: string[]) {
         assert.equal(actualFileNames.length, expectedFileNames.length, `${caption}: incorrect actual number of files, expected ${JSON.stringify(expectedFileNames)}, got ${actualFileNames}`);
         for (const f of expectedFileNames) {
@@ -291,38 +297,30 @@ namespace ts.projectSystem {
     }
 
     export class Callbacks {
-        private map: { [n: number]: TimeOutCallback } = {};
+        private map = createMap<TimeOutCallback>();
         private nextId = 1;
 
         register(cb: (...args: any[]) => void, args: any[]) {
             const timeoutId = this.nextId;
             this.nextId++;
-            this.map[timeoutId] = cb.bind(undefined, ...args);
+            this.map.set(timeoutId, cb.bind(undefined, ...args));
             return timeoutId;
         }
         unregister(id: any) {
             if (typeof id === "number") {
-                delete this.map[id];
+                this.map.delete(id);
             }
         }
 
         count() {
-            let n = 0;
-            for (const _ in this.map) {
-                // TODO: GH#11734
-                _;
-                n++;
-            }
-            return n;
+            return mapSize(this.map);
         }
 
         invoke() {
-            for (const id in this.map) {
-                if (hasProperty(this.map, id)) {
-                    this.map[id]();
-                }
-            }
-            this.map = {};
+            this.map.forEach(cb => {
+                cb();
+            });
+            this.map.clear();
         }
     }
 
@@ -439,7 +437,7 @@ namespace ts.projectSystem {
 
         triggerDirectoryWatcherCallback(directoryName: string, fileName: string): void {
             const path = this.toPath(directoryName);
-            const callbacks = this.watchedDirectories[path];
+            const callbacks = this.watchedDirectories.get(path);
             if (callbacks) {
                 for (const callback of callbacks) {
                     callback.cb(fileName);
@@ -449,7 +447,7 @@ namespace ts.projectSystem {
 
         triggerFileWatcherCallback(fileName: string, removed?: boolean): void {
             const path = this.toPath(fileName);
-            const callbacks = this.watchedFiles[path];
+            const callbacks = this.watchedFiles.get(path);
             if (callbacks) {
                 for (const callback of callbacks) {
                     callback(path, removed);
diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts
index 62d2f7ac801..d99f12294af 100644
--- a/src/harness/unittests/typingsInstaller.ts
+++ b/src/harness/unittests/typingsInstaller.ts
@@ -14,7 +14,7 @@ namespace ts.projectSystem {
     function createTypesRegistry(...list: string[]): Map<void> {
         const map = createMap<void>();
         for (const l of list) {
-            map[l] = undefined;
+            map.set(l, undefined);
         }
         return map;
     }
diff --git a/src/server/builder.ts b/src/server/builder.ts
index 5354e7ed508..44fb2224371 100644
--- a/src/server/builder.ts
+++ b/src/server/builder.ts
@@ -336,24 +336,24 @@ namespace ts.server {
             // Use slice to clone the array to avoid manipulating in place
             const queue = fileInfo.referencedBy.slice(0);
             const fileNameSet = createMap<ScriptInfo>();
-            fileNameSet[scriptInfo.fileName] = scriptInfo;
+            fileNameSet.set(scriptInfo.fileName, scriptInfo);
             while (queue.length > 0) {
                 const processingFileInfo = queue.pop();
                 if (processingFileInfo.updateShapeSignature() && processingFileInfo.referencedBy.length > 0) {
                     for (const potentialFileInfo of processingFileInfo.referencedBy) {
-                        if (!fileNameSet[potentialFileInfo.scriptInfo.fileName]) {
+                        if (!fileNameSet.has(potentialFileInfo.scriptInfo.fileName)) {
                             queue.push(potentialFileInfo);
                         }
                     }
                 }
-                fileNameSet[processingFileInfo.scriptInfo.fileName] = processingFileInfo.scriptInfo;
+                fileNameSet.set(processingFileInfo.scriptInfo.fileName, processingFileInfo.scriptInfo);
             }
             const result: string[] = [];
-            for (const fileName in fileNameSet) {
-                if (shouldEmitFile(fileNameSet[fileName])) {
+            fileNameSet.forEach((scriptInfo, fileName) => {
+                if (shouldEmitFile(scriptInfo)) {
                     result.push(fileName);
                 }
-            }
+            });
             return result;
         }
     }
diff --git a/src/server/client.ts b/src/server/client.ts
index 3b09a926754..13d16073d1c 100644
--- a/src/server/client.ts
+++ b/src/server/client.ts
@@ -31,10 +31,10 @@ namespace ts.server {
         }
 
         private getLineMap(fileName: string): number[] {
-            let lineMap = this.lineMaps[fileName];
+            let lineMap = this.lineMaps.get(fileName);
             if (!lineMap) {
                 const scriptSnapshot = this.host.getScriptSnapshot(fileName);
-                lineMap = this.lineMaps[fileName] = ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength()));
+                lineMap = set(this.lineMaps, fileName, ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength())));
             }
             return lineMap;
         }
@@ -140,7 +140,7 @@ namespace ts.server {
 
         changeFile(fileName: string, start: number, end: number, newText: string): void {
             // clear the line map after an edit
-            this.lineMaps[fileName] = undefined;
+            this.lineMaps.set(fileName, undefined);
 
             const lineOffset = this.positionToOneBasedLineOffset(fileName, start);
             const endLineOffset = this.positionToOneBasedLineOffset(fileName, end);
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 9e53b3cd526..a358b0dab00 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\compiler\commandLineParser.ts" />
+/// <reference path="..\compiler\commandLineParser.ts" />
 /// <reference path="..\services\services.ts" />
 /// <reference path="utilities.ts" />
 /// <reference path="session.ts" />
@@ -41,10 +41,10 @@ namespace ts.server {
             if (typeof option.type === "object") {
                 const optionMap = <Map<number>>option.type;
                 // verify that map contains only numbers
-                for (const id in optionMap) {
-                    Debug.assert(typeof optionMap[id] === "number");
-                }
-                map[option.name] = optionMap;
+                optionMap.forEach(value => {
+                    Debug.assert(typeof value === "number");
+                });
+                map.set(option.name, optionMap);
             }
         }
         return map;
@@ -59,20 +59,19 @@ namespace ts.server {
 
     export function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings {
         if (typeof protocolOptions.indentStyle === "string") {
-            protocolOptions.indentStyle = indentStyle[protocolOptions.indentStyle.toLowerCase()];
+            protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase());
             Debug.assert(protocolOptions.indentStyle !== undefined);
         }
         return <any>protocolOptions;
     }
 
     export function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin {
-        for (const id in compilerOptionConverters) {
+        compilerOptionConverters.forEach((mappedValues, id) => {
             const propertyValue = protocolOptions[id];
             if (typeof propertyValue === "string") {
-                const mappedValues = compilerOptionConverters[id];
-                protocolOptions[id] = mappedValues[propertyValue.toLowerCase()];
+                protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());
             }
-        }
+        });
         return <any>protocolOptions;
     }
 
@@ -189,11 +188,12 @@ namespace ts.server {
 
         stopWatchingDirectory(directory: string) {
             // if the ref count for this directory watcher drops to 0, it's time to close it
-            this.directoryWatchersRefCount[directory]--;
-            if (this.directoryWatchersRefCount[directory] === 0) {
+            const refCount = this.directoryWatchersRefCount.get(directory) - 1;
+            this.directoryWatchersRefCount.set(directory, refCount);
+            if (refCount === 0) {
                 this.projectService.logger.info(`Close directory watcher for: ${directory}`);
-                this.directoryWatchersForTsconfig[directory].close();
-                delete this.directoryWatchersForTsconfig[directory];
+                this.directoryWatchersForTsconfig.get(directory).close();
+                this.directoryWatchersForTsconfig.delete(directory);
             }
         }
 
@@ -201,13 +201,13 @@ namespace ts.server {
             let currentPath = getDirectoryPath(fileName);
             let parentPath = getDirectoryPath(currentPath);
             while (currentPath != parentPath) {
-                if (!this.directoryWatchersForTsconfig[currentPath]) {
+                if (!this.directoryWatchersForTsconfig.has(currentPath)) {
                     this.projectService.logger.info(`Add watcher for: ${currentPath}`);
-                    this.directoryWatchersForTsconfig[currentPath] = this.projectService.host.watchDirectory(currentPath, callback);
-                    this.directoryWatchersRefCount[currentPath] = 1;
+                    this.directoryWatchersForTsconfig.set(currentPath, this.projectService.host.watchDirectory(currentPath, callback));
+                    this.directoryWatchersRefCount.set(currentPath, 1);
                 }
                 else {
-                    this.directoryWatchersRefCount[currentPath] += 1;
+                    this.directoryWatchersRefCount.set(currentPath, this.directoryWatchersRefCount.get(currentPath) + 1);
                 }
                 project.directoriesWatchedForTsconfig.push(currentPath);
                 currentPath = parentPath;
@@ -425,7 +425,7 @@ namespace ts.server {
             }
             else {
                 if (info && (!info.isOpen)) {
-                    // file has been changed which might affect the set of referenced files in projects that include 
+                    // file has been changed which might affect the set of referenced files in projects that include
                     // this file and set of inferred projects
                     info.reloadFromFile();
                     this.updateProjectGraphs(info.containingProjects);
@@ -444,7 +444,7 @@ namespace ts.server {
                 this.filenameToScriptInfo.remove(info.path);
                 this.lastDeletedFile = info;
 
-                // capture list of projects since detachAllProjects will wipe out original list 
+                // capture list of projects since detachAllProjects will wipe out original list
                 const containingProjects = info.containingProjects.slice();
 
                 info.detachAllProjects();
@@ -600,7 +600,7 @@ namespace ts.server {
                 const inferredProject = this.createInferredProjectWithRootFileIfNecessary(info);
                 if (!this.useSingleInferredProject) {
                     // if useOneInferredProject is not set then try to fixup ownership of open files
-                    // check 'defaultProject !== inferredProject' is necessary to handle cases 
+                    // check 'defaultProject !== inferredProject' is necessary to handle cases
                     // when creation inferred project for some file has added other open files into this project (i.e. as referenced files)
                     // we definitely don't want to delete the project that was just created
                     for (const f of this.openFiles) {
@@ -610,7 +610,7 @@ namespace ts.server {
                         }
                         const defaultProject = f.getDefaultProject();
                         if (isRootFileInInferredProject(info) && defaultProject !== inferredProject && inferredProject.containsScriptInfo(f)) {
-                            // open file used to be root in inferred project, 
+                            // open file used to be root in inferred project,
                             // this inferred project is different from the one we've just created for current file
                             // and new inferred project references this open file.
                             // We should delete old inferred project and attach open file to the new one
@@ -990,7 +990,7 @@ namespace ts.server {
                 if (toAdd) {
                     for (const f of toAdd) {
                         if (f.isOpen && isRootFileInInferredProject(f)) {
-                            // if file is already root in some inferred project 
+                            // if file is already root in some inferred project
                             // - remove the file from that project and delete the project if necessary
                             const inferredProject = f.containingProjects[0];
                             inferredProject.removeFile(f);
@@ -1143,7 +1143,7 @@ namespace ts.server {
                     this.logger.info(`Host information ${args.hostInfo}`);
                 }
                 if (args.formatOptions) {
-                    mergeMaps(this.hostConfiguration.formatCodeOptions, convertFormatOptions(args.formatOptions));
+                    mergeMapLikes(this.hostConfiguration.formatCodeOptions, convertFormatOptions(args.formatOptions));
                     this.logger.info("Format host information updated");
                 }
             }
@@ -1265,7 +1265,7 @@ namespace ts.server {
                 for (const file of changedFiles) {
                     const scriptInfo = this.getScriptInfo(file.fileName);
                     Debug.assert(!!scriptInfo);
-                    // apply changes in reverse order 
+                    // apply changes in reverse order
                     for (let i = file.changes.length - 1; i >= 0; i--) {
                         const change = file.changes[i];
                         scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText);
@@ -1302,7 +1302,7 @@ namespace ts.server {
 
         closeExternalProject(uncheckedFileName: string, suppressRefresh = false): void {
             const fileName = toNormalizedPath(uncheckedFileName);
-            const configFiles = this.externalProjectToConfiguredProjectMap[fileName];
+            const configFiles = this.externalProjectToConfiguredProjectMap.get(fileName);
             if (configFiles) {
                 let shouldRefreshInferredProjects = false;
                 for (const configFile of configFiles) {
@@ -1310,7 +1310,7 @@ namespace ts.server {
                         shouldRefreshInferredProjects = true;
                     }
                 }
-                delete this.externalProjectToConfiguredProjectMap[fileName];
+                this.externalProjectToConfiguredProjectMap.delete(fileName);
                 if (shouldRefreshInferredProjects && !suppressRefresh) {
                     this.refreshInferredProjects();
                 }
@@ -1331,19 +1331,19 @@ namespace ts.server {
             // record project list before the update
             const projectsToClose = arrayToMap(this.externalProjects, p => p.getProjectName(), _ => true);
             for (const externalProjectName in this.externalProjectToConfiguredProjectMap) {
-                projectsToClose[externalProjectName] = true;
+                projectsToClose.set(externalProjectName, true);
             }
 
             for (const externalProject of projects) {
                 this.openExternalProject(externalProject, /*suppressRefreshOfInferredProjects*/ true);
                 // delete project that is present in input list
-                delete projectsToClose[externalProject.projectFileName];
+                projectsToClose.delete(externalProject.projectFileName);
             }
 
             // close projects that were missing in the input list
-            for (const externalProjectName in projectsToClose) {
+            forEachKeyInMap(projectsToClose, externalProjectName => {
                 this.closeExternalProject(externalProjectName, /*suppressRefresh*/ true)
-            }
+            });
 
             this.refreshInferredProjects();
         }
@@ -1386,7 +1386,7 @@ namespace ts.server {
                 // close existing project and later we'll open a set of configured projects for these files
                 this.closeExternalProject(proj.projectFileName, /*suppressRefresh*/ true);
             }
-            else if (this.externalProjectToConfiguredProjectMap[proj.projectFileName]) {
+            else if (this.externalProjectToConfiguredProjectMap.get(proj.projectFileName)) {
                 // this project used to include config files
                 if (!tsConfigFiles) {
                     // config files were removed from the project - close existing external project which in turn will close configured projects
@@ -1394,7 +1394,7 @@ namespace ts.server {
                 }
                 else {
                     // project previously had some config files - compare them with new set of files and close all configured projects that correspond to unused files
-                    const oldConfigFiles = this.externalProjectToConfiguredProjectMap[proj.projectFileName];
+                    const oldConfigFiles = this.externalProjectToConfiguredProjectMap.get(proj.projectFileName);
                     let iNew = 0;
                     let iOld = 0;
                     while (iNew < tsConfigFiles.length && iOld < oldConfigFiles.length) {
@@ -1422,7 +1422,7 @@ namespace ts.server {
             }
             if (tsConfigFiles) {
                 // store the list of tsconfig files that belong to the external project
-                this.externalProjectToConfiguredProjectMap[proj.projectFileName] = tsConfigFiles;
+                this.externalProjectToConfiguredProjectMap.set(proj.projectFileName, tsConfigFiles);
                 for (const tsconfigFile of tsConfigFiles) {
                     let project = this.findConfiguredProjectByProjectName(tsconfigFile);
                     if (!project) {
@@ -1438,7 +1438,7 @@ namespace ts.server {
             }
             else {
                 // no config files - remove the item from the collection
-                delete this.externalProjectToConfiguredProjectMap[proj.projectFileName];
+                this.externalProjectToConfiguredProjectMap.delete(proj.projectFileName);
                 this.createAndAddExternalProject(proj.projectFileName, rootFiles, proj.options, proj.typeAcquisition);
             }
             if (!suppressRefreshOfInferredProjects) {
diff --git a/src/server/lsHost.ts b/src/server/lsHost.ts
index aa37008ff66..ffeeb57a0e8 100644
--- a/src/server/lsHost.ts
+++ b/src/server/lsHost.ts
@@ -75,15 +75,16 @@ namespace ts.server {
 
             for (const name of names) {
                 // check if this is a duplicate entry in the list
-                let resolution = newResolutions[name];
+                let resolution = newResolutions.get(name);
                 if (!resolution) {
-                    const existingResolution = currentResolutionsInFile && currentResolutionsInFile[name];
+                    const existingResolution = currentResolutionsInFile && currentResolutionsInFile.get(name);
                     if (moduleResolutionIsValid(existingResolution)) {
                         // ok, it is safe to use existing name resolution results
                         resolution = existingResolution;
                     }
                     else {
-                        newResolutions[name] = resolution = loader(name, containingFile, compilerOptions, this);
+                        resolution = loader(name, containingFile, compilerOptions, this);
+                        newResolutions.set(name, resolution);
                     }
                     if (logChanges && this.filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
                         this.filesWithChangedSetOfUnresolvedImports.push(path);
diff --git a/src/server/project.ts b/src/server/project.ts
index 049f61269f8..14889dccd8a 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -495,9 +495,9 @@ namespace ts.server {
             }
             let unresolvedImports: string[];
             if (file.resolvedModules) {
-                for (const name in file.resolvedModules) {
+                file.resolvedModules.forEach((resolvedModule, name) => {
                     // pick unresolved non-relative names
-                    if (!file.resolvedModules[name] && !isExternalModuleNameRelative(name)) {
+                    if (!resolvedModule && !isExternalModuleNameRelative(name)) {
                         // for non-scoped names extract part up-to the first slash
                         // for scoped names - extract up to the second slash
                         let trimmed = name.trim();
@@ -511,7 +511,7 @@ namespace ts.server {
                         (unresolvedImports || (unresolvedImports = [])).push(trimmed);
                         result.push(trimmed);
                     }
-                }
+                });
             }
             this.cachedUnresolvedImportsPerFile.set(file.path, unresolvedImports || emptyArray);
         }
@@ -537,7 +537,7 @@ namespace ts.server {
             }
 
             // 1. no changes in structure, no changes in unresolved imports - do nothing
-            // 2. no changes in structure, unresolved imports were changed - collect unresolved imports for all files 
+            // 2. no changes in structure, unresolved imports were changed - collect unresolved imports for all files
             // (can reuse cached imports for files that were not changed)
             // 3. new files were added/removed, but compilation settings stays the same - collect unresolved imports for all new/modified files
             // (can reuse cached imports for files that were not changed)
@@ -679,16 +679,16 @@ namespace ts.server {
 
                 const added: string[] = [];
                 const removed: string[] = [];
-                for (const id in currentFiles) {
-                    if (!hasProperty(lastReportedFileNames, id)) {
+                forEachKeyInMap(currentFiles, id => {
+                    if (!lastReportedFileNames.has(id)) {
                         added.push(id);
                     }
-                }
-                for (const id in lastReportedFileNames) {
-                    if (!hasProperty(currentFiles, id)) {
+                });
+                forEachKeyInMap(lastReportedFileNames, id => {
+                    if (!currentFiles.has(id)) {
                         removed.push(id);
                     }
-                }
+                });
                 this.lastReportedFileNames = currentFiles;
                 this.lastReportedVersion = this.projectStructureVersion;
                 return { info, changes: { added, removed }, projectErrors: this.projectErrors };
@@ -722,7 +722,7 @@ namespace ts.server {
                     if (symbol && symbol.declarations && symbol.declarations[0]) {
                         const declarationSourceFile = symbol.declarations[0].getSourceFile();
                         if (declarationSourceFile) {
-                            referencedFiles[declarationSourceFile.path] = true;
+                            referencedFiles.set(declarationSourceFile.path, true);
                         }
                     }
                 }
@@ -734,25 +734,24 @@ namespace ts.server {
             if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) {
                 for (const referencedFile of sourceFile.referencedFiles) {
                     const referencedPath = toPath(referencedFile.fileName, currentDirectory, getCanonicalFileName);
-                    referencedFiles[referencedPath] = true;
+                    referencedFiles.set(referencedPath, true);
                 }
             }
 
             // Handle type reference directives
             if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-                for (const typeName in sourceFile.resolvedTypeReferenceDirectiveNames) {
-                    const resolvedTypeReferenceDirective = sourceFile.resolvedTypeReferenceDirectiveNames[typeName];
+                sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
                     if (!resolvedTypeReferenceDirective) {
-                        continue;
+                        return;
                     }
 
                     const fileName = resolvedTypeReferenceDirective.resolvedFileName;
                     const typeFilePath = toPath(fileName, currentDirectory, getCanonicalFileName);
-                    referencedFiles[typeFilePath] = true;
-                }
+                    referencedFiles.set(typeFilePath, true);
+                })
             }
 
-            const allFileNames = map(Object.keys(referencedFiles), key => <Path>key);
+            const allFileNames = keysOfMap(referencedFiles) as Path[];
             return filter(allFileNames, file => this.projectService.host.fileExists(file));
         }
 
@@ -888,18 +887,19 @@ namespace ts.server {
                 return;
             }
             const configDirectoryPath = getDirectoryPath(this.getConfigFilePath());
-            this.directoriesWatchedForWildcards = reduceProperties(this.wildcardDirectories, (watchers, flag, directory) => {
+
+            this.directoriesWatchedForWildcards = createMap<FileWatcher>();
+            this.wildcardDirectories.forEach((flag, directory) => {
                 if (comparePaths(configDirectoryPath, directory, ".", !this.projectService.host.useCaseSensitiveFileNames) !== Comparison.EqualTo) {
                     const recursive = (flag & WatchDirectoryFlags.Recursive) !== 0;
                     this.projectService.logger.info(`Add ${recursive ? "recursive " : ""}watcher for: ${directory}`);
-                    watchers[directory] = this.projectService.host.watchDirectory(
+                    this.directoriesWatchedForWildcards.set(directory, this.projectService.host.watchDirectory(
                         directory,
                         path => callback(this, path),
                         recursive
-                    );
+                    ));
                 }
-                return watchers;
-            }, <Map<FileWatcher>>{});
+            });
         }
 
         stopWatchingDirectory() {
@@ -923,9 +923,9 @@ namespace ts.server {
                 this.typeRootsWatchers = undefined;
             }
 
-            for (const id in this.directoriesWatchedForWildcards) {
-                this.directoriesWatchedForWildcards[id].close();
-            }
+            this.directoriesWatchedForWildcards.forEach(watcher => {
+                watcher.close();
+            });
             this.directoriesWatchedForWildcards = undefined;
 
             this.stopWatchingDirectory();
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
index 84649863a7b..fa9eac0e8e3 100644
--- a/src/server/scriptInfo.ts
+++ b/src/server/scriptInfo.ts
@@ -95,7 +95,7 @@ namespace ts.server {
                 if (!this.formatCodeSettings) {
                     this.formatCodeSettings = getDefaultFormatCodeSettings(this.host);
                 }
-                mergeMaps(this.formatCodeSettings, formatSettings);
+                mergeMapLikes(this.formatCodeSettings, formatSettings);
             }
         }
 
diff --git a/src/server/session.ts b/src/server/session.ts
index 9abc5a447bf..0c200b33b84 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -1607,14 +1607,14 @@ namespace ts.server {
         });
 
         public addProtocolHandler(command: string, handler: (request: protocol.Request) => { response?: any, responseRequired: boolean }) {
-            if (command in this.handlers) {
+            if (this.handlers.has(command)) {
                 throw new Error(`Protocol handler already exists for command "${command}"`);
             }
-            this.handlers[command] = handler;
+            this.handlers.set(command, handler);
         }
 
         public executeCommand(request: protocol.Request): { response?: any, responseRequired?: boolean } {
-            const handler = this.handlers[request.command];
+            const handler = this.handlers.get(request.command);
             if (handler) {
                 return handler(request);
             }
diff --git a/src/server/typingsCache.ts b/src/server/typingsCache.ts
index 8b03d59003c..9379ae82d0e 100644
--- a/src/server/typingsCache.ts
+++ b/src/server/typingsCache.ts
@@ -35,17 +35,18 @@ namespace ts.server {
         let unique = 0;
 
         for (const v of arr1) {
-            if (set[v] !== true) {
-                set[v] = true;
+            if (set.get(v) !== true) {
+                set.set(v, true);
                 unique++;
             }
         }
         for (const v of arr2) {
-            if (!hasProperty(set, v)) {
+            const isSet = set.get(v);
+            if (isSet === undefined) {
                 return false;
             }
-            if (set[v] === true) {
-                set[v] = false;
+            if (isSet === true) {
+                set.set(v, false);
                 unique--;
             }
         }
@@ -83,7 +84,7 @@ namespace ts.server {
                 return <any>emptyArray;
             }
 
-            const entry = this.perProjectCache[project.getProjectName()];
+            const entry = this.perProjectCache.get(project.getProjectName());
             const result: SortedReadonlyArray<string> = entry ? entry.typings : <any>emptyArray;
             if (forceRefresh ||
                 !entry ||
@@ -92,13 +93,13 @@ namespace ts.server {
                 unresolvedImportsChanged(unresolvedImports, entry.unresolvedImports)) {
                 // Note: entry is now poisoned since it does not really contain typings for a given combination of compiler options\typings options.
                 // instead it acts as a placeholder to prevent issuing multiple requests
-                this.perProjectCache[project.getProjectName()] = {
+                this.perProjectCache.set(project.getProjectName(), {
                     compilerOptions: project.getCompilerOptions(),
                     typeAcquisition,
                     typings: result,
                     unresolvedImports,
                     poisoned: true
-                };
+                });
                 // something has been changed, issue a request to update typings
                 this.installer.enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
             }
@@ -106,21 +107,21 @@ namespace ts.server {
         }
 
         updateTypingsForProject(projectName: string, compilerOptions: CompilerOptions, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string>, newTypings: string[]) {
-            this.perProjectCache[projectName] = {
+            this.perProjectCache.set(projectName, {
                 compilerOptions,
                 typeAcquisition,
                 typings: toSortedReadonlyArray(newTypings),
                 unresolvedImports,
                 poisoned: false
-            };
+            });
         }
 
         deleteTypingsForProject(projectName: string) {
-            delete this.perProjectCache[projectName];
+            this.perProjectCache.delete(projectName);
         }
 
         onProjectClosed(project: Project) {
-            delete this.perProjectCache[project.getProjectName()];
+            this.perProjectCache.delete(project.getProjectName());
             this.installer.onProjectClosed(project);
         }
     }
diff --git a/src/server/typingsInstaller/typingsInstaller.ts b/src/server/typingsInstaller/typingsInstaller.ts
index 7a09c1f6c21..82184f86850 100644
--- a/src/server/typingsInstaller/typingsInstaller.ts
+++ b/src/server/typingsInstaller/typingsInstaller.ts
@@ -112,7 +112,7 @@ namespace ts.server.typingsInstaller {
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Closing file watchers for project '${projectName}'`);
             }
-            const watchers = this.projectWatchers[projectName];
+            const watchers = this.projectWatchers.get(projectName);
             if (!watchers) {
                 if (this.log.isEnabled()) {
                     this.log.writeLine(`No watchers are registered for project '${projectName}'`);
@@ -123,7 +123,7 @@ namespace ts.server.typingsInstaller {
                 w.close();
             }
 
-            delete this.projectWatchers[projectName];
+            this.projectWatchers.delete(projectName);
 
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Closing file watchers for project '${projectName}' - done.`);
@@ -177,7 +177,7 @@ namespace ts.server.typingsInstaller {
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Processing cache location '${cacheLocation}'`);
             }
-            if (this.knownCachesSet[cacheLocation]) {
+            if (this.knownCachesSet.get(cacheLocation)) {
                 if (this.log.isEnabled()) {
                     this.log.writeLine(`Cache location was already processed...`);
                 }
@@ -201,10 +201,10 @@ namespace ts.server.typingsInstaller {
                         }
                         const typingFile = typingToFileName(cacheLocation, packageName, this.installTypingHost, this.log);
                         if (!typingFile) {
-                            this.missingTypingsSet[packageName] = true;
+                            this.missingTypingsSet.set(packageName, true);
                             continue;
                         }
-                        const existingTypingFile = this.packageNameToTypingLocation[packageName];
+                        const existingTypingFile = this.packageNameToTypingLocation.get(packageName);
                         if (existingTypingFile === typingFile) {
                             continue;
                         }
@@ -216,14 +216,14 @@ namespace ts.server.typingsInstaller {
                         if (this.log.isEnabled()) {
                             this.log.writeLine(`Adding entry into typings cache: '${packageName}' => '${typingFile}'`);
                         }
-                        this.packageNameToTypingLocation[packageName] = typingFile;
+                        this.packageNameToTypingLocation.set(packageName, typingFile);
                     }
                 }
             }
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Finished processing cache location '${cacheLocation}'`);
             }
-            this.knownCachesSet[cacheLocation] = true;
+            this.knownCachesSet.set(cacheLocation, true);
         }
 
         private filterTypings(typingsToInstall: string[]) {
@@ -232,12 +232,12 @@ namespace ts.server.typingsInstaller {
             }
             const result: string[] = [];
             for (const typing of typingsToInstall) {
-                if (this.missingTypingsSet[typing] || this.packageNameToTypingLocation[typing]) {
+                if (this.missingTypingsSet.get(typing) || this.packageNameToTypingLocation.get(typing)) {
                     continue;
                 }
                 const validationResult = validatePackageName(typing);
                 if (validationResult === PackageNameValidationResult.Ok) {
-                    if (typing in this.typesRegistry) {
+                    if (this.typesRegistry.has(typing)) {
                         result.push(typing);
                     }
                     else {
@@ -248,7 +248,7 @@ namespace ts.server.typingsInstaller {
                 }
                 else {
                     // add typing name to missing set so we won't process it again
-                    this.missingTypingsSet[typing] = true;
+                    this.missingTypingsSet.set(typing, true);
                     if (this.log.isEnabled()) {
                         switch (validationResult) {
                             case PackageNameValidationResult.EmptyName:
@@ -323,7 +323,7 @@ namespace ts.server.typingsInstaller {
                             this.log.writeLine(`install request failed, marking packages as missing to prevent repeated requests: ${JSON.stringify(filteredTypings)}`);
                         }
                         for (const typing of filteredTypings) {
-                            this.missingTypingsSet[typing] = true;
+                            this.missingTypingsSet.set(typing, true);
                         }
                         return;
                     }
@@ -336,11 +336,11 @@ namespace ts.server.typingsInstaller {
                     for (const packageName of filteredTypings) {
                         const typingFile = typingToFileName(cachePath, packageName, this.installTypingHost, this.log);
                         if (!typingFile) {
-                            this.missingTypingsSet[packageName] = true;
+                            this.missingTypingsSet.set(packageName, true);
                             continue;
                         }
-                        if (!this.packageNameToTypingLocation[packageName]) {
-                            this.packageNameToTypingLocation[packageName] = typingFile;
+                        if (!this.packageNameToTypingLocation.has(packageName)) {
+                            this.packageNameToTypingLocation.set(packageName, typingFile);
                         }
                         installedTypingFiles.push(typingFile);
                     }
@@ -395,7 +395,7 @@ namespace ts.server.typingsInstaller {
                 }, /*pollingInterval*/ 2000);
                 watchers.push(w);
             }
-            this.projectWatchers[projectName] = watchers;
+            this.projectWatchers.set(projectName, watchers);
         }
 
         private createSetTypings(request: DiscoverTypings, typings: string[]): SetTypings {
diff --git a/src/server/utilities.ts b/src/server/utilities.ts
index fd370da7fa1..eb7801e5fd9 100644
--- a/src/server/utilities.ts
+++ b/src/server/utilities.ts
@@ -92,7 +92,7 @@ namespace ts.server {
         };
     }
 
-    export function mergeMaps(target: MapLike<any>, source: MapLike <any>): void {
+    export function mergeMapLikes(target: MapLike<any>, source: MapLike <any>): void {
         for (const key in source) {
             if (hasProperty(source, key)) {
                 target[key] = source[key];
@@ -142,20 +142,20 @@ namespace ts.server {
 
     export function createNormalizedPathMap<T>(): NormalizedPathMap<T> {
 /* tslint:disable:no-null-keyword */
-        const map: Map<T> = Object.create(null);
+        const map = createMap<T>();
 /* tslint:enable:no-null-keyword */
         return {
             get(path) {
-                return map[path];
+                return map.get(path);
             },
             set(path, value) {
-                map[path] = value;
+                map.set(path, value);
             },
             contains(path) {
-                return hasProperty(map, path);
+                return map.has(path);
             },
             remove(path) {
-                delete map[path];
+                map.delete(path);
             }
         };
     }
@@ -195,16 +195,17 @@ namespace ts.server {
         }
 
         public schedule(operationId: string, delay: number, cb: () => void) {
-            if (hasProperty(this.pendingTimeouts, operationId)) {
+            const pendingTimeout = this.pendingTimeouts.get(operationId);
+            if (pendingTimeout) {
                 // another operation was already scheduled for this id - cancel it
-                this.host.clearTimeout(this.pendingTimeouts[operationId]);
+                this.host.clearTimeout(pendingTimeout);
             }
             // schedule new operation, pass arguments
-            this.pendingTimeouts[operationId] = this.host.setTimeout(ThrottledOperations.run, delay, this, operationId, cb);
+            this.pendingTimeouts.set(operationId, this.host.setTimeout(ThrottledOperations.run, delay, this, operationId, cb));
         }
 
         private static run(self: ThrottledOperations, operationId: string, cb: () => void) {
-            delete self.pendingTimeouts[operationId];
+            self.pendingTimeouts.delete(operationId);
             cb();
         }
     }
diff --git a/src/services/classifier.ts b/src/services/classifier.ts
index c22aec6a786..6c143ec2af0 100644
--- a/src/services/classifier.ts
+++ b/src/services/classifier.ts
@@ -557,7 +557,7 @@ namespace ts {
                     // Only bother calling into the typechecker if this is an identifier that
                     // could possibly resolve to a type name.  This makes classification run
                     // in a third of the time it would normally take.
-                    if (classifiableNames[identifier.text]) {
+                    if (classifiableNames.get(identifier.text)) {
                         const symbol = typeChecker.getSymbolAtLocation(node);
                         if (symbol) {
                             const type = classifySymbol(symbol, getMeaningFromLocation(node));
diff --git a/src/services/codefixes/codeFixProvider.ts b/src/services/codefixes/codeFixProvider.ts
index e4489fc2dca..c6373fc1909 100644
--- a/src/services/codefixes/codeFixProvider.ts
+++ b/src/services/codefixes/codeFixProvider.ts
@@ -20,21 +20,21 @@ namespace ts {
 
         export function registerCodeFix(action: CodeFix) {
             forEach(action.errorCodes, error => {
-                let fixes = codeFixes[error];
+                let fixes = codeFixes.get(error);
                 if (!fixes) {
                     fixes = [];
-                    codeFixes[error] = fixes;
+                    codeFixes.set(error, fixes);
                 }
                 fixes.push(action);
             });
         }
 
         export function getSupportedErrorCodes() {
-            return Object.keys(codeFixes);
+            return keysOfMap(codeFixes);
         }
 
         export function getFixes(context: CodeFixContext): CodeAction[] {
-            const fixes = codeFixes[context.errorCode];
+            const fixes = codeFixes.get(context.errorCode);
             let allActions: CodeAction[] = [];
 
             forEach(fixes, f => {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index bda310f2d33..0e7743e29fc 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -21,18 +21,19 @@ namespace ts.codefix {
                 return;
             }
 
-            if (!this.symbolIdToActionMap[symbolId]) {
-                this.symbolIdToActionMap[symbolId] = [newAction];
+            const actions = this.symbolIdToActionMap.get(symbolId);
+            if (!actions) {
+                this.symbolIdToActionMap.set(symbolId, [newAction]);
                 return;
             }
 
             if (newAction.kind === "CodeChange") {
-                this.symbolIdToActionMap[symbolId].push(newAction);
+                actions.push(newAction);
                 return;
             }
 
             const updatedNewImports: ImportCodeAction[] = [];
-            for (const existingAction of this.symbolIdToActionMap[symbolId]) {
+            for (const existingAction of this.symbolIdToActionMap.get(symbolId)) {
                 if (existingAction.kind === "CodeChange") {
                     // only import actions should compare
                     updatedNewImports.push(existingAction);
@@ -62,7 +63,7 @@ namespace ts.codefix {
             }
             // if we reach here, it means the new one is better or equal to all of the existing ones.
             updatedNewImports.push(newAction);
-            this.symbolIdToActionMap[symbolId] = updatedNewImports;
+            this.symbolIdToActionMap.set(symbolId, updatedNewImports);
         }
 
         addActions(symbolId: number, newActions: ImportCodeAction[]) {
@@ -73,9 +74,9 @@ namespace ts.codefix {
 
         getAllActions() {
             let result: ImportCodeAction[] = [];
-            for (const symbolId in this.symbolIdToActionMap) {
-                result = concatenate(result, this.symbolIdToActionMap[symbolId]);
-            }
+            this.symbolIdToActionMap.forEach(actions => {
+                result = concatenate(result, actions);
+            });
             return result;
         }
 
@@ -162,8 +163,9 @@ namespace ts.codefix {
             function getImportDeclarations(moduleSymbol: Symbol) {
                 const moduleSymbolId = getUniqueSymbolId(moduleSymbol);
 
-                if (cachedImportDeclarations[moduleSymbolId]) {
-                    return cachedImportDeclarations[moduleSymbolId];
+                const cached = cachedImportDeclarations.get(moduleSymbolId);
+                if (cached) {
+                    return cached;
                 }
 
                 const existingDeclarations: (ImportDeclaration | ImportEqualsDeclaration)[] = [];
@@ -173,7 +175,7 @@ namespace ts.codefix {
                         existingDeclarations.push(getImportDeclaration(importModuleSpecifier));
                     }
                 }
-                cachedImportDeclarations[moduleSymbolId] = existingDeclarations;
+                cachedImportDeclarations.set(moduleSymbolId, existingDeclarations);
                 return existingDeclarations;
 
                 function getImportDeclaration(moduleSpecifier: LiteralExpression) {
diff --git a/src/services/completions.ts b/src/services/completions.ts
index b710aa8cd78..f7efe1fec56 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -64,14 +64,14 @@ namespace ts.Completions {
             const entries: CompletionEntry[] = [];
 
             const nameTable = getNameTable(sourceFile);
-            for (const name in nameTable) {
+            nameTable.forEach((namePosition, name) => {
                 // Skip identifiers produced only from the current location
-                if (nameTable[name] === position) {
-                    continue;
+                if (namePosition === position) {
+                    return;
                 }
 
-                if (!uniqueNames[name]) {
-                    uniqueNames[name] = name;
+                if (!uniqueNames.get(name)) {
+                    uniqueNames.set(name, name);
                     const displayName = getCompletionEntryDisplayName(unescapeIdentifier(name), compilerOptions.target, /*performCharacterChecks*/ true);
                     if (displayName) {
                         const entry = {
@@ -83,7 +83,7 @@ namespace ts.Completions {
                         entries.push(entry);
                     }
                 }
-            }
+            });
 
             return entries;
         }
@@ -122,9 +122,9 @@ namespace ts.Completions {
                     const entry = createCompletionEntry(symbol, location, performCharacterChecks);
                     if (entry) {
                         const id = escapeIdentifier(entry.name);
-                        if (!uniqueNames[id]) {
+                        if (!uniqueNames.get(id)) {
                             entries.push(entry);
-                            uniqueNames[id] = id;
+                            uniqueNames.set(id, id);
                         }
                     }
                 }
@@ -373,14 +373,14 @@ namespace ts.Completions {
 
                         const foundFileName = includeExtensions ? getBaseFileName(filePath) : removeFileExtension(getBaseFileName(filePath));
 
-                        if (!foundFiles[foundFileName]) {
-                            foundFiles[foundFileName] = true;
+                        if (!foundFiles.get(foundFileName)) {
+                            foundFiles.set(foundFileName, true);
                         }
                     }
 
-                    for (const foundFile in foundFiles) {
+                    forEachKeyInMap(foundFiles, foundFile => {
                         result.push(createCompletionEntryForModule(foundFile, ScriptElementKind.scriptElement, span));
-                    }
+                    });
                 }
 
                 // If possible, get folder completion as well
@@ -1563,14 +1563,14 @@ namespace ts.Completions {
                 }
 
                 const name = element.propertyName || element.name;
-                existingImportsOrExports[name.text] = true;
+                existingImportsOrExports.set(name.text, true);
             }
 
-            if (!someProperties(existingImportsOrExports)) {
+            if (mapIsEmpty(existingImportsOrExports)) {
                 return filter(exportsOfModule, e => e.name !== "default");
             }
 
-            return filter(exportsOfModule, e => e.name !== "default" && !existingImportsOrExports[e.name]);
+            return filter(exportsOfModule, e => e.name !== "default" && !existingImportsOrExports.get(e.name));
         }
 
         /**
@@ -1616,10 +1616,10 @@ namespace ts.Completions {
                     existingName = (<Identifier>m.name).text;
                 }
 
-                existingMemberNames[existingName] = true;
+                existingMemberNames.set(existingName, true);
             }
 
-            return filter(contextualMemberSymbols, m => !existingMemberNames[m.name]);
+            return filter(contextualMemberSymbols, m => !existingMemberNames.get(m.name));
         }
 
         /**
@@ -1637,11 +1637,11 @@ namespace ts.Completions {
                 }
 
                 if (attr.kind === SyntaxKind.JsxAttribute) {
-                    seenNames[(<JsxAttribute>attr).name.text] = true;
+                    seenNames.set((<JsxAttribute>attr).name.text, true);
                 }
             }
 
-            return filter(symbols, a => !seenNames[a.name]);
+            return filter(symbols, a => !seenNames.get(a.name));
         }
     }
 
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 0f18427e568..212e145ca60 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -44,11 +44,11 @@ namespace ts.DocumentHighlights {
                 for (const referencedSymbol of referencedSymbols) {
                     for (const referenceEntry of referencedSymbol.references) {
                         const fileName = referenceEntry.fileName;
-                        let documentHighlights = fileNameToDocumentHighlights[fileName];
+                        let documentHighlights = fileNameToDocumentHighlights.get(fileName);
                         if (!documentHighlights) {
                             documentHighlights = { fileName, highlightSpans: [] };
 
-                            fileNameToDocumentHighlights[fileName] = documentHighlights;
+                            fileNameToDocumentHighlights.set(fileName, documentHighlights);
                             result.push(documentHighlights);
                         }
 
diff --git a/src/services/documentRegistry.ts b/src/services/documentRegistry.ts
index d73e4d3b0a1..4291abf6c1f 100644
--- a/src/services/documentRegistry.ts
+++ b/src/services/documentRegistry.ts
@@ -113,16 +113,16 @@ namespace ts {
         }
 
         function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
-            let bucket = buckets[key];
+            let bucket = buckets.get(key);
             if (!bucket && createIfMissing) {
-                buckets[key] = bucket = createFileMap<DocumentRegistryEntry>();
+                buckets.set(key, bucket = createFileMap<DocumentRegistryEntry>());
             }
             return bucket;
         }
 
         function reportStats() {
-            const bucketInfoArray = Object.keys(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
-                const entries = buckets[name];
+            const bucketInfoArray = keysOfMap(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
+                const entries = buckets.get(name);
                 const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
                 entries.forEachValue((key, entry) => {
                     sourceFiles.push({
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 313a3d2ea3e..9e53537b69b 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -96,7 +96,7 @@ namespace ts.FindAllReferences {
 
                 const nameTable = getNameTable(sourceFile);
 
-                if (nameTable[internedName] !== undefined) {
+                if (nameTable.get(internedName) !== undefined) {
                     result = result || [];
                     getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
                 }
@@ -501,14 +501,14 @@ namespace ts.FindAllReferences {
             function findOwnConstructorCalls(classSymbol: Symbol): Node[] {
                 const result: Node[] = [];
 
-                for (const decl of classSymbol.members["__constructor"].declarations) {
+                for (const decl of classSymbol.members.get("__constructor").declarations) {
                     Debug.assert(decl.kind === SyntaxKind.Constructor);
                     const ctrKeyword = decl.getChildAt(0);
                     Debug.assert(ctrKeyword.kind === SyntaxKind.ConstructorKeyword);
                     result.push(ctrKeyword);
                 }
 
-                forEachProperty(classSymbol.exports, member => {
+                forEachInMap(classSymbol.exports, member => {
                     const decl = member.valueDeclaration;
                     if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
                         const body = (<MethodDeclaration>decl).body;
@@ -528,7 +528,7 @@ namespace ts.FindAllReferences {
             /** Find references to `super` in the constructor of an extending class.  */
             function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
                 const symbol = cls.symbol;
-                const ctr = symbol.members["__constructor"];
+                const ctr = symbol.members.get("__constructor");
                 if (!ctr) {
                     return [];
                 }
@@ -715,12 +715,13 @@ namespace ts.FindAllReferences {
                 }
 
                 const key = getSymbolId(symbol) + "," + getSymbolId(parent);
-                if (key in cachedResults) {
-                    return cachedResults[key];
+                const cached = cachedResults.get(key);
+                if (cached !== undefined) {
+                    return cached;
                 }
 
                 // Set the key so that we don't infinitely recurse
-                cachedResults[key] = false;
+                cachedResults.set(key, false);
 
                 const inherits = forEach(symbol.getDeclarations(), declaration => {
                     if (isClassLike(declaration)) {
@@ -744,7 +745,7 @@ namespace ts.FindAllReferences {
                     return false;
                 });
 
-                cachedResults[key] = inherits;
+                cachedResults.set(key, inherits);
                 return inherits;
             }
 
@@ -1078,7 +1079,7 @@ namespace ts.FindAllReferences {
             // the function will add any found symbol of the property-name, then its sub-routine will call
             // getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
             // visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
-            if (symbol.name in previousIterationSymbolsCache) {
+            if (previousIterationSymbolsCache.has(symbol.name)) {
                 return;
             }
 
@@ -1105,7 +1106,7 @@ namespace ts.FindAllReferences {
                         }
 
                         // Visit the typeReference as well to see if it directly or indirectly use that property
-                        previousIterationSymbolsCache[symbol.name] = symbol;
+                        previousIterationSymbolsCache.set(symbol.name, symbol);
                         getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache);
                     }
                 }
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
index 2095f062bd1..215289159c2 100644
--- a/src/services/formatting/rules.ts
+++ b/src/services/formatting/rules.ts
@@ -4,7 +4,7 @@
 namespace ts.formatting {
     export class Rules {
         public getRuleName(rule: Rule) {
-            const o: ts.Map<any> = <any>this;
+            const o: ts.MapLike<any> = <any>this;
             for (const name in o) {
                 if (o[name] === rule) {
                     return name;
diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts
index 4c005640d6a..d6ade7aed6b 100644
--- a/src/services/goToDefinition.ts
+++ b/src/services/goToDefinition.ts
@@ -14,7 +14,7 @@ namespace ts.GoToDefinition {
         // Type reference directives
         const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
         if (typeReferenceDirective) {
-            const referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
+            const referenceFile = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName);
             if (referenceFile && referenceFile.resolvedFileName) {
                 return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
             }
diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts
index 04ac60c4e74..e587a14b459 100644
--- a/src/services/jsTyping.ts
+++ b/src/services/jsTyping.ts
@@ -17,11 +17,11 @@ namespace ts.JsTyping {
 
     interface PackageJson {
         _requiredBy?: string[];
-        dependencies?: Map<string>;
-        devDependencies?: Map<string>;
+        dependencies?: MapLike<string>;
+        devDependencies?: MapLike<string>;
         name?: string;
-        optionalDependencies?: Map<string>;
-        peerDependencies?: Map<string>;
+        optionalDependencies?: MapLike<string>;
+        peerDependencies?: MapLike<string>;
         typings?: string;
     };
 
@@ -107,34 +107,34 @@ namespace ts.JsTyping {
         // add typings for unresolved imports
         if (unresolvedImports) {
             for (const moduleId of unresolvedImports) {
-                const typingName = moduleId in nodeCoreModules ? "node" : moduleId;
-                if (!(typingName in inferredTypings)) {
-                    inferredTypings[typingName] = undefined;
+                const typingName = nodeCoreModules.has(moduleId) ? "node" : moduleId;
+                if (!inferredTypings.has(typingName)) {
+                    inferredTypings.set(typingName, undefined);
                 }
             }
         }
         // Add the cached typing locations for inferred typings that are already installed
-        for (const name in packageNameToTypingLocation) {
-            if (name in inferredTypings && !inferredTypings[name]) {
-                inferredTypings[name] = packageNameToTypingLocation[name];
+        packageNameToTypingLocation.forEach((typingLocation, name) => {
+            if (inferredTypings.has(name) && inferredTypings.get(name) === undefined) {
+                inferredTypings.set(name, typingLocation);
             }
-        }
+        });
 
         // Remove typings that the user has added to the exclude list
         for (const excludeTypingName of exclude) {
-            delete inferredTypings[excludeTypingName];
+            inferredTypings.delete(excludeTypingName);
         }
 
         const newTypingNames: string[] = [];
         const cachedTypingPaths: string[] = [];
-        for (const typing in inferredTypings) {
-            if (inferredTypings[typing] !== undefined) {
-                cachedTypingPaths.push(inferredTypings[typing]);
+        inferredTypings.forEach((inferred, typing) => {
+            if (inferred !== undefined) {
+                cachedTypingPaths.push(inferred);
             }
             else {
                 newTypingNames.push(typing);
             }
-        }
+        });
         return { cachedTypingPaths, newTypingNames, filesToWatch };
 
         /**
@@ -146,8 +146,8 @@ namespace ts.JsTyping {
             }
 
             for (const typing of typingNames) {
-                if (!(typing in inferredTypings)) {
-                    inferredTypings[typing] = undefined;
+                if (!inferredTypings.has(typing)) {
+                    inferredTypings.set(typing, undefined);
                 }
             }
         }
@@ -189,7 +189,7 @@ namespace ts.JsTyping {
             const cleanedTypingNames = map(inferredTypingNames, f => f.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, ""));
 
             if (safeList !== EmptySafeList) {
-                mergeTypings(filter(cleanedTypingNames, f => f in safeList));
+                mergeTypings(filter(cleanedTypingNames, f => safeList.has(f)));
             }
 
             const hasJsxFile = forEach(fileNames, f => ensureScriptKind(f, getScriptKindFromFileName(f)) === ScriptKind.JSX);
@@ -236,7 +236,7 @@ namespace ts.JsTyping {
                 }
                 if (packageJson.typings) {
                     const absolutePath = getNormalizedAbsolutePath(packageJson.typings, getDirectoryPath(normalizedFileName));
-                    inferredTypings[packageJson.name] = absolutePath;
+                    inferredTypings.set(packageJson.name, absolutePath);
                 }
                 else {
                     typingNames.push(packageJson.name);
diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts
index 82f4dd49f2b..40f22941268 100644
--- a/src/services/navigateTo.ts
+++ b/src/services/navigateTo.ts
@@ -7,23 +7,21 @@ namespace ts.NavigateTo {
         let rawItems: RawNavigateToItem[] = [];
 
         // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
-        forEach(sourceFiles, sourceFile => {
+        for (const sourceFile of sourceFiles) {
             cancellationToken.throwIfCancellationRequested();
 
             if (excludeDtsFiles && fileExtensionIs(sourceFile.fileName, ".d.ts")) {
-                return;
+                continue;
             }
 
-            const nameToDeclarations = sourceFile.getNamedDeclarations();
-            for (const name in nameToDeclarations) {
-                const declarations = nameToDeclarations[name];
+            forEachInMap(sourceFile.getNamedDeclarations(), (declarations, name) => {
                 if (declarations) {
                     // First do a quick check to see if the name of the declaration matches the
                     // last portion of the (possibly) dotted name they're searching for.
                     let matches = patternMatcher.getMatchesForLastSegmentOfPattern(name);
 
                     if (!matches) {
-                        continue;
+                        return; // continue to next named declarations
                     }
 
                     for (const declaration of declarations) {
@@ -32,13 +30,13 @@ namespace ts.NavigateTo {
                         if (patternMatcher.patternContainsDots) {
                             const containers = getContainers(declaration);
                             if (!containers) {
-                                return undefined;
+                                return true; // Break out of named declarations and go to the next source file.
                             }
 
                             matches = patternMatcher.getMatches(containers, name);
 
                             if (!matches) {
-                                continue;
+                                return; // continue to next named declarations
                             }
                         }
 
@@ -47,8 +45,8 @@ namespace ts.NavigateTo {
                         rawItems.push({ name, fileName, matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration });
                     }
                 }
-            }
-        });
+            });
+        }
 
         // Remove imports when the imported declaration is already in the list and has the same name.
         rawItems = filter(rawItems, item => {
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index 1cbaa3d640f..7d95787939d 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -248,9 +248,9 @@ namespace ts.NavigationBar {
                 return true;
             }
 
-            const itemsWithSameName = nameToItems[name];
+            const itemsWithSameName = nameToItems.get(name);
             if (!itemsWithSameName) {
-                nameToItems[name] = child;
+                nameToItems.set(name, child);
                 return true;
             }
 
@@ -268,7 +268,7 @@ namespace ts.NavigationBar {
                 if (tryMerge(itemWithSameName, child)) {
                     return false;
                 }
-                nameToItems[name] = [itemWithSameName, child];
+                nameToItems.set(name, [itemWithSameName, child]);
                 return true;
             }
 
@@ -626,15 +626,15 @@ namespace ts.NavigationBar {
 
     /**
      * Matches all whitespace characters in a string. Eg:
-     * 
+     *
      * "app.
-     * 
+     *
      * onactivated"
-     * 
+     *
      * matches because of the newline, whereas
-     * 
+     *
      * "app.onactivated"
-     * 
+     *
      * does not match.
      */
     const whiteSpaceRegex = /\s+/g;
diff --git a/src/services/patternMatcher.ts b/src/services/patternMatcher.ts
index b4f67ca056d..b8941ef3147 100644
--- a/src/services/patternMatcher.ts
+++ b/src/services/patternMatcher.ts
@@ -188,11 +188,7 @@ namespace ts {
         }
 
         function getWordSpans(word: string): TextSpan[] {
-            if (!(word in stringToWordSpans)) {
-                stringToWordSpans[word] = breakIntoWordSpans(word);
-            }
-
-            return stringToWordSpans[word];
+            return stringToWordSpans.get(word) || set(stringToWordSpans, word, breakIntoWordSpans(word));
         }
 
         function matchTextChunk(candidate: string, chunk: TextChunk, punctuationStripped: boolean): PatternMatch {
diff --git a/src/services/services.ts b/src/services/services.ts
index d28dd871105..77a5e916067 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -532,7 +532,7 @@ namespace ts {
             }
 
             function getDeclarations(name: string) {
-                return result[name] || (result[name] = []);
+                return result.get(name) || set(result, name, []);
             }
 
             function getDeclarationName(declaration: Declaration) {
@@ -1956,9 +1956,11 @@ namespace ts {
 
         function walk(node: Node) {
             switch (node.kind) {
-                case SyntaxKind.Identifier:
-                    nameTable[(<Identifier>node).text] = nameTable[(<Identifier>node).text] === undefined ? node.pos : -1;
+                case SyntaxKind.Identifier: {
+                    const text = (<Identifier>node).text;
+                    nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
                     break;
+                }
                 case SyntaxKind.StringLiteral:
                 case SyntaxKind.NumericLiteral:
                     // We want to store any numbers/strings if they were a name that could be
@@ -1970,7 +1972,8 @@ namespace ts {
                         isArgumentOfElementAccessExpression(node) ||
                         isLiteralComputedPropertyDeclarationName(node)) {
 
-                        nameTable[(<LiteralExpression>node).text] = nameTable[(<LiteralExpression>node).text] === undefined ? node.pos : -1;
+                        const text = (<LiteralExpression>node).text;
+                        nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
                     }
                     break;
                 default:
diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts
index 44c2ede9fbb..aa799eb32c7 100644
--- a/src/services/signatureHelp.ts
+++ b/src/services/signatureHelp.ts
@@ -237,7 +237,7 @@ namespace ts.SignatureHelp {
         const typeChecker = program.getTypeChecker();
         for (const sourceFile of program.getSourceFiles()) {
             const nameToDeclarations = sourceFile.getNamedDeclarations();
-            const declarations = nameToDeclarations[name.text];
+            const declarations = nameToDeclarations.get(name.text);
 
             if (declarations) {
                 for (const declaration of declarations) {
diff --git a/src/services/transpile.ts b/src/services/transpile.ts
index da54faed1a2..d989a528497 100644
--- a/src/services/transpile.ts
+++ b/src/services/transpile.ts
@@ -126,7 +126,7 @@ namespace ts {
     function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
         // Lazily create this value to fix module loading errors.
         commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
-            typeof o.type === "object" && !forEachProperty(o.type, v => typeof v !== "number"));
+            typeof o.type === "object" && !forEachInMap(o.type, v => typeof v !== "number"));
 
         options = clone(options);
 
@@ -142,7 +142,7 @@ namespace ts {
                 options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
             }
             else {
-                if (!forEachProperty(opt.type, v => v === value)) {
+                if (!someInMap(opt.type, v => v === value)) {
                     // Supplied value isn't a valid enum value.
                     diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
                 }
diff --git a/tests/baselines/reference/computedPropertyNames10_ES5.types b/tests/baselines/reference/computedPropertyNames10_ES5.types
index 650890fb10e..96130979298 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES5.types
+++ b/tests/baselines/reference/computedPropertyNames10_ES5.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: () => void; [x: number]: () => void; [0](): void; [""](): void; }
->{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : { [x: string]: () => void; [x: number]: () => void; [0](): void; [""](): void; }
+>v : { [x: string]: () => void; [x: number]: () => void; [""](): void; [0](): void; }
+>{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : { [x: string]: () => void; [x: number]: () => void; [""](): void; [0](): void; }
 
     [s]() { },
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNames10_ES6.types b/tests/baselines/reference/computedPropertyNames10_ES6.types
index 2ff86ed9712..5bbda2e8f19 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES6.types
+++ b/tests/baselines/reference/computedPropertyNames10_ES6.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: () => void; [x: number]: () => void; [0](): void; [""](): void; }
->{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : { [x: string]: () => void; [x: number]: () => void; [0](): void; [""](): void; }
+>v : { [x: string]: () => void; [x: number]: () => void; [""](): void; [0](): void; }
+>{    [s]() { },    [n]() { },    [s + s]() { },    [s + n]() { },    [+s]() { },    [""]() { },    [0]() { },    [a]() { },    [<any>true]() { },    [`hello bye`]() { },    [`hello ${a} bye`]() { }} : { [x: string]: () => void; [x: number]: () => void; [""](): void; [0](): void; }
 
     [s]() { },
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNames11_ES5.types b/tests/baselines/reference/computedPropertyNames11_ES5.types
index 0787a889f40..88fbc690323 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES5.types
+++ b/tests/baselines/reference/computedPropertyNames11_ES5.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: any; [x: number]: any; readonly [0]: number; [""]: any; }
->{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : { [x: string]: any; [x: number]: any; readonly [0]: number; [""]: any; }
+>v : { [x: string]: any; [x: number]: any; [""]: any; readonly [0]: number; }
+>{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : { [x: string]: any; [x: number]: any; [""]: any; readonly [0]: number; }
 
     get [s]() { return 0; },
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNames11_ES6.types b/tests/baselines/reference/computedPropertyNames11_ES6.types
index 4783d07a2af..458d6d1de49 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES6.types
+++ b/tests/baselines/reference/computedPropertyNames11_ES6.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: any; [x: number]: any; readonly [0]: number; [""]: any; }
->{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : { [x: string]: any; [x: number]: any; readonly [0]: number; [""]: any; }
+>v : { [x: string]: any; [x: number]: any; [""]: any; readonly [0]: number; }
+>{    get [s]() { return 0; },    set [n](v) { },    get [s + s]() { return 0; },    set [s + n](v) { },    get [+s]() { return 0; },    set [""](v) { },    get [0]() { return 0; },    set [a](v) { },    get [<any>true]() { return 0; },    set [`hello bye`](v) { },    get [`hello ${a} bye`]() { return 0; }} : { [x: string]: any; [x: number]: any; [""]: any; readonly [0]: number; }
 
     get [s]() { return 0; },
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNames4_ES5.types b/tests/baselines/reference/computedPropertyNames4_ES5.types
index 64ef5f6a611..6f875aaddac 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES5.types
+++ b/tests/baselines/reference/computedPropertyNames4_ES5.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: string | number; [x: number]: string | number; [0]: number; [""]: number; }
->{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : { [x: string]: string | number; [x: number]: string | number; [0]: number; [""]: number; }
+>v : { [x: string]: string | number; [x: number]: string | number; [""]: number; [0]: number; }
+>{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : { [x: string]: string | number; [x: number]: string | number; [""]: number; [0]: number; }
 
     [s]: 0,
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNames4_ES6.types b/tests/baselines/reference/computedPropertyNames4_ES6.types
index 0c608e21601..e9feac0a81f 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES6.types
+++ b/tests/baselines/reference/computedPropertyNames4_ES6.types
@@ -9,8 +9,8 @@ var a: any;
 >a : any
 
 var v = {
->v : { [x: string]: string | number; [x: number]: string | number; [0]: number; [""]: number; }
->{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : { [x: string]: string | number; [x: number]: string | number; [0]: number; [""]: number; }
+>v : { [x: string]: string | number; [x: number]: string | number; [""]: number; [0]: number; }
+>{    [s]: 0,    [n]: n,    [s + s]: 1,    [s + n]: 2,    [+s]: s,    [""]: 0,    [0]: 0,    [a]: 1,    [<any>true]: 0,    [`hello bye`]: 0,    [`hello ${a} bye`]: 0} : { [x: string]: string | number; [x: number]: string | number; [""]: number; [0]: number; }
 
     [s]: 0,
 >s : string
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types
index 91ad88c8ade..f144bb9d020 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types
@@ -19,7 +19,7 @@ declare function foo<T>(obj: I<T>): T
 foo({
 >foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: true | "" | (() => void) | 0 | number[]; [x: number]: (() => void) | 0 | number[]; 0: () => void; p: ""; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: true | "" | (() => void) | 0 | number[]; [x: number]: (() => void) | 0 | number[]; p: ""; 0: () => void; }
 
     p: "",
 >p : string
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types
index 131e49dd173..6b8c8ae2e34 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types
@@ -19,7 +19,7 @@ declare function foo<T>(obj: I<T>): T
 foo({
 >foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: true | "" | (() => void) | 0 | number[]; [x: number]: (() => void) | 0 | number[]; 0: () => void; p: ""; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: true | "" | (() => void) | 0 | number[]; [x: number]: (() => void) | 0 | number[]; p: ""; 0: () => void; }
 
     p: "",
 >p : string
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types
index 94a5f2173aa..32e5b33e411 100644
--- a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts ===
 
 var object = {
->object : { 0: number; _0: number; }
->{    _0: 2,    get 0() {        return this._0;    },    set 0(x: number) {        this._0 = x;    },} : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
+>{    _0: 2,    get 0() {        return this._0;    },    set 0(x: number) {        this._0 = x;    },} : { _0: number; 0: number; }
 
     _0: 2,
 >_0 : number
@@ -30,31 +30,31 @@ var object = {
 object[0] **= object[0];
 >object[0] **= object[0] : number
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 
 object[0] **= object[0] **= 2;
 >object[0] **= object[0] **= 2 : number
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 >object[0] **= 2 : number
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 >2 : 2
 
 object[0] **= object[0] ** 2;
 >object[0] **= object[0] ** 2 : number
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 >object[0] ** 2 : number
 >object[0] : number
->object : { 0: number; _0: number; }
+>object : { _0: number; 0: number; }
 >0 : 0
 >2 : 2
 
diff --git a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
index ec0f330f1a3..f532bd23755 100644
--- a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
@@ -5,7 +5,7 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(36,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(50,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(68,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(79,5): error TS2322: Type '{ 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo(): string; }' is not assignable to type '{ [x: number]: string; }'.
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(79,5): error TS2322: Type '{ a: string; b: number; c: () => void; "d": string; "e": number; 1.0: string; 2.0: number; "3.0": string; "4.0": number; f: any; X: string; foo(): string; }' is not assignable to type '{ [x: number]: string; }'.
   Object literal may only specify known properties, and 'a' does not exist in type '{ [x: number]: string; }'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(88,9): error TS2304: Cannot find name 'Myn'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(90,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -107,7 +107,7 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
     var b: { [x: number]: string; } = {
         a: '',
         ~~~~~
-!!! error TS2322: Type '{ 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo(): string; }' is not assignable to type '{ [x: number]: string; }'.
+!!! error TS2322: Type '{ a: string; b: number; c: () => void; "d": string; "e": number; 1.0: string; 2.0: number; "3.0": string; "4.0": number; f: any; X: string; foo(): string; }' is not assignable to type '{ [x: number]: string; }'.
 !!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ [x: number]: string; }'.
         b: 1, 
         c: () => { }, 
diff --git a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
index e6d22ff0712..74cd032c40e 100644
--- a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
@@ -1,7 +1,7 @@
 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(44,5): error TS2322: Type '{ 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(44,5): error TS2322: Type '{ 1.0: A; 2.0: B; "2.5": B; 3.0: number; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
   Object literal may only specify known properties, and '"4.0"' does not exist in type '{ [x: number]: A; }'.
 
 
@@ -57,6 +57,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         3.0: 1,
         "4.0": ''
         ~~~~~~~~~
-!!! error TS2322: Type '{ 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 '{ 1.0: A; 2.0: B; "2.5": B; 3.0: number; "4.0": string; }' is not assignable to type '{ [x: number]: A; }'.
 !!! error TS2322:   Object literal may only specify known properties, and '"4.0"' does not exist in type '{ [x: number]: A; }'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/numericIndexerConstraint5.errors.txt b/tests/baselines/reference/numericIndexerConstraint5.errors.txt
index cb888de08c4..04b7e0dc337 100644
--- a/tests/baselines/reference/numericIndexerConstraint5.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstraint5.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/numericIndexerConstraint5.ts(2,5): error TS2322: Type '{ 0: Date; name: string; }' is not assignable to type '{ [name: number]: string; }'.
+tests/cases/compiler/numericIndexerConstraint5.ts(2,5): error TS2322: Type '{ name: string; 0: Date; }' is not assignable to type '{ [name: number]: string; }'.
   Property '0' is incompatible with index signature.
     Type 'Date' is not assignable to type 'string'.
 
@@ -7,6 +7,6 @@ tests/cases/compiler/numericIndexerConstraint5.ts(2,5): error TS2322: Type '{ 0:
     var x = { name: "x", 0: new Date() };
     var z: { [name: number]: string } = x;
         ~
-!!! error TS2322: Type '{ 0: Date; name: string; }' is not assignable to type '{ [name: number]: string; }'.
+!!! error TS2322: Type '{ name: string; 0: Date; }' is not assignable to type '{ [name: number]: string; }'.
 !!! error TS2322:   Property '0' is incompatible with index signature.
 !!! error TS2322:     Type 'Date' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt b/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
index 9d5ff7ea0a2..53abb5b7658 100644
--- a/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
+++ b/tests/baselines/reference/objectLiteralIndexerErrors.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/objectLiteralIndexerErrors.ts(13,5): error TS2322: Type '{ 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: B; 0: A; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
   Property '0' is incompatible with index signature.
     Type 'A' is not assignable to type 'B'.
       Property 'y' is missing in type 'A'.
-tests/cases/compiler/objectLiteralIndexerErrors.ts(14,1): error TS2322: Type '{ 0: A; x: any; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
+tests/cases/compiler/objectLiteralIndexerErrors.ts(14,1): error TS2322: Type '{ x: any; 0: A; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
   Property '0' is incompatible with index signature.
     Type 'A' is not assignable to type 'B'.
 
@@ -22,12 +22,12 @@ tests/cases/compiler/objectLiteralIndexerErrors.ts(14,1): error TS2322: Type '{
     
     var o1: { [s: string]: A;[n: number]: B; } = { x: b, 0: a }; // both indexers are A
         ~~
-!!! error TS2322: Type '{ 0: A; x: B; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
+!!! error TS2322: Type '{ x: B; 0: A; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
 !!! error TS2322:   Property '0' is incompatible with index signature.
 !!! error TS2322:     Type 'A' is not assignable to type 'B'.
 !!! error TS2322:       Property 'y' is missing in type 'A'.
     o1 = { x: c, 0: a }; // string indexer is any, number indexer is A
     ~~
-!!! error TS2322: Type '{ 0: A; x: any; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
+!!! error TS2322: Type '{ x: any; 0: A; }' is not assignable to type '{ [s: string]: A; [n: number]: B; }'.
 !!! error TS2322:   Property '0' is incompatible with index signature.
 !!! error TS2322:     Type 'A' is not assignable to type 'B'.
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLiteralIndexers.types b/tests/baselines/reference/objectLiteralIndexers.types
index 9e3aa4bac49..ef242fd1fe3 100644
--- a/tests/baselines/reference/objectLiteralIndexers.types
+++ b/tests/baselines/reference/objectLiteralIndexers.types
@@ -31,23 +31,23 @@ 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 } : { 0: B; x: A; }
+>{ x: a, 0: b } : { x: A; 0: B; }
 >x : A
 >a : A
 >b : B
 
 o1 = { x: b, 0: c }; // both indexers are any
->o1 = { x: b, 0: c } : { 0: any; x: B; }
+>o1 = { x: b, 0: c } : { x: B; 0: any; }
 >o1 : { [s: string]: A; [n: number]: B; }
->{ x: b, 0: c } : { 0: any; x: B; }
+>{ x: b, 0: c } : { x: B; 0: any; }
 >x : B
 >b : B
 >c : any
 
 o1 = { x: c, 0: b }; // string indexer is any, number indexer is B
->o1 = { x: c, 0: b } : { 0: B; x: any; }
+>o1 = { x: c, 0: b } : { x: any; 0: B; }
 >o1 : { [s: string]: A; [n: number]: B; }
->{ x: c, 0: b } : { 0: B; x: any; }
+>{ x: c, 0: b } : { x: any; 0: B; }
 >x : any
 >c : any
 >b : B
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
index e050d33024c..1f34c4fafac 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
@@ -267,7 +267,7 @@ var r13 = i[-01]
 >01 : 1
 
 var a: {
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 
     "0.1": void;
     ".1": Object;
@@ -289,19 +289,19 @@ var a: {
 var r1 = a['0.1'];
 >r1 : void
 >a['0.1'] : void
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'0.1' : "0.1"
 
 var r2 = a['.1'];
 >r2 : Object
 >a['.1'] : Object
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'.1' : ".1"
 
 var r3 = a['1'];
 >r3 : number
 >a['1'] : number
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'1' : "1"
 
 var r3 = c[1];
@@ -313,7 +313,7 @@ var r3 = c[1];
 var r4 = a['1.'];
 >r4 : string
 >a['1.'] : string
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'1.' : "1."
 
 var r3 = c[1.]; // same as indexing by 1 when done numerically
@@ -325,13 +325,13 @@ var r3 = c[1.]; // same as indexing by 1 when done numerically
 var r5 = a['1..'];
 >r5 : boolean
 >a['1..'] : boolean
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'1..' : "1.."
 
 var r6 = a['1.0'];
 >r6 : Date
 >a['1.0'] : Date
->a : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
 >'1.0' : "1.0"
 
 var r3 = c[1.0]; // same as indexing by 1 when done numerically
@@ -394,8 +394,8 @@ var r13 = i[-01]
 >01 : 1
 
 var b = {
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
->{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 
     "0.1": <void>null,
 ><void>null : void
@@ -429,19 +429,19 @@ var b = {
 var r1 = b['0.1'];
 >r1 : void
 >b['0.1'] : void
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'0.1' : "0.1"
 
 var r2 = b['.1'];
 >r2 : Object
 >b['.1'] : Object
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'.1' : ".1"
 
 var r3 = b['1'];
 >r3 : number
 >b['1'] : number
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'1' : "1"
 
 var r3 = c[1];
@@ -453,7 +453,7 @@ var r3 = c[1];
 var r4 = b['1.'];
 >r4 : string
 >b['1.'] : string
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'1.' : "1."
 
 var r3 = c[1.]; // same as indexing by 1 when done numerically
@@ -465,13 +465,13 @@ var r3 = c[1.]; // same as indexing by 1 when done numerically
 var r5 = b['1..'];
 >r5 : boolean
 >b['1..'] : boolean
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'1..' : "1.."
 
 var r6 = b['1.0'];
 >r6 : Date
 >b['1.0'] : Date
->b : { "1": number; "0.1": void; ".1": Object; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
 >'1.0' : "1.0"
 
 var r3 = c[1.0]; // same as indexing by 1 when done numerically
diff --git a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
index 8f4bbe2025a..606cc39afef 100644
--- a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
@@ -22,8 +22,8 @@ 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 '{ 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; }'.
-  Property '2.0' is incompatible with index signature.
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ a: string; b: number; c: () => void; "d": string; "e": number; 1.0: string; 2.0: number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
+  Property 'b' is incompatible with index signature.
     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.
@@ -157,8 +157,8 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
     // error
     var b: { [x: string]: string; } = {
         ~
-!!! error TS2322: Type '{ 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:   Property '2.0' is incompatible with index signature.
+!!! error TS2322: Type '{ a: string; b: number; c: () => void; "d": string; "e": number; 1.0: string; 2.0: number; "3.0": string; "4.0": number; f: MyString; X: string; foo(): string; }' is not assignable to type '{ [x: string]: string; }'.
+!!! error TS2322:   Property 'b' is incompatible with index signature.
 !!! error TS2322:     Type 'number' is not assignable to type 'string'.
         a: '',
         b: 1, 
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index 745a746db11..f97e122aabb 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -43,6 +43,16 @@
 // TODO: figure out a better solution to the API exposure problem.
 
 declare module ts {
+    export type MapKey = string | number;
+    export interface Map<T> {
+        forEach(action: (value: T, key: string) => void): void;
+        get(key: MapKey): T;
+        has(key: MapKey): boolean;
+        set(key: MapKey, value: T): this;
+        delete(key: MapKey): boolean;
+        clear(): void;
+    }
+
     interface SymbolDisplayPart {
         text: string;
         kind: string;
@@ -103,7 +113,7 @@ declare namespace FourSlashInterface {
         markerNames(): string[];
         marker(name?: string): Marker;
         ranges(): Range[];
-        rangesByText(): { [text: string]: Range[] };
+        rangesByText(): ts.Map<Range[]>;
         markerByName(s: string): Marker;
     }
     class goTo {
diff --git a/tests/cases/fourslash/localGetReferences.ts b/tests/cases/fourslash/localGetReferences.ts
index b05346a366a..fa9e59cabcf 100644
--- a/tests/cases/fourslash/localGetReferences.ts
+++ b/tests/cases/fourslash/localGetReferences.ts
@@ -202,15 +202,14 @@ goTo.marker("4");
 verify.referencesAre([]);
 
 const rangesByText = test.rangesByText();
-for (const text in rangesByText) {
-    const ranges = rangesByText[text];
+rangesByText.forEach((ranges, text) => {
     if (text === "globalVar") {
         verify.rangesReferenceEachOther(ranges.filter(isShadow));
         verify.rangesReferenceEachOther(ranges.filter(r => !isShadow(r)));
     } else {
         verify.rangesReferenceEachOther(ranges);
     }
-}
+});
 
 function isShadow(r) {
     return r.marker && r.marker.data && r.marker.data.shadow;
diff --git a/tslint.json b/tslint.json
index 26657981a63..13de7acec63 100644
--- a/tslint.json
+++ b/tslint.json
@@ -46,6 +46,7 @@
         "prefer-const": true,
         "no-increment-decrement": true,
         "object-literal-surrounding-space": true,
-        "no-type-assertion-whitespace": true
+        "no-type-assertion-whitespace": true,
+        "no-in-operator": true
   }
 }

From b15ffda7f699097c7abf49252558dcafb3da3a50 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 8 Dec 2016 06:55:49 -0800
Subject: [PATCH 020/159] Simplify forEachKeyInMap and someKeyInMap

---
 src/compiler/checker.ts |  2 +-
 src/compiler/core.ts    | 46 +++++++++--------------------------------
 2 files changed, 11 insertions(+), 37 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 00a6ad2c366..67c4db715e2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -18991,7 +18991,7 @@ namespace ts {
         }
 
         function hasExportedMembers(moduleSymbol: Symbol) {
-            return someKeyInMap(moduleSymbol.exports, id => id !== "export=");
+            return someInMap(moduleSymbol.exports, (_, id) => id !== "export=");
         }
 
         function checkExternalModuleExports(node: SourceFile | ModuleDeclaration) {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index affd225b3a7..3fe3b386701 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -68,7 +68,6 @@ namespace ts {
     interface ES6Map<T> extends Map<T> {
         readonly size: number;
         entries(): Iterator<[string, T]>;
-        keys(): Iterator<string>;
     }
 
     /** ES6 Iterator type. */
@@ -80,9 +79,7 @@ namespace ts {
     interface ShimMap<T> extends Map<T> {
         isEmpty(): boolean;
         forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined;
-        forEachKey<U>(callback: (key: string) => U | undefined): U | undefined;
         some(predicate: (value: T, key: string) => boolean): boolean;
-        someKey(predicate: (key: string) => boolean): boolean;
     }
 
     // The global Map object. This may not be available, so we must test for it.
@@ -130,16 +127,12 @@ namespace ts {
             }
 
             isEmpty(): boolean {
-                return !this.someKey(() => true);
+                return !this.some(() => true);
             }
 
             forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined {
-                return this.forEachKey(key => callback(this.data[key], key));
-            }
-
-            forEachKey<U>(callback: (key: string) => U | undefined): U | undefined {
                 for (const key in this.data) {
-                    const result = callback(key);
+                    const result = callback(this.data[key], key);
                     if (result !== undefined) {
                         return result;
                     }
@@ -147,12 +140,8 @@ namespace ts {
             }
 
             some(predicate: (value: T, key: string) => boolean): boolean {
-                return this.someKey(key => predicate(this.data[key], key));
-            }
-
-            someKey(predicate: (key: string) => boolean): boolean {
                 for (const key in this.data) {
-                    if (predicate(key)) {
+                    if (predicate(this.data[key], key)) {
                         return true;
                     }
                 }
@@ -939,17 +928,9 @@ namespace ts {
         : <T, U>(map: ShimMap<T>, callback: (value: T, key: string) => U | undefined) => map.forEachInMap(callback);
 
     /** `forEachInMap` for just keys. */
-    export const forEachKeyInMap: <T>(map: Map<{}>, callback: (key: string) => T | undefined) => T | undefined = usingNativeMaps
-        ? <T>(map: ES6Map<T>, callback: (key: string) => T | undefined) => {
-            const iterator = map.keys();
-            while (true) {
-                const { value: key, done } = iterator.next();
-                if (done) return undefined;
-                const result = callback(key);
-                if (result !== undefined) return result;
-            }
-        }
-        : <T>(map: ShimMap<T>, callback: (key: string) => T | undefined) => map.forEachKey(callback);
+    export function forEachKeyInMap<T>(map: Map<{}>, callback: (key: string) => T | undefined): T | undefined {
+        return forEachInMap(map, (_, key) => callback(key));
+    }
 
     /** Whether `predicate` is true for some entry in the map. */
     export const someInMap: <T>(map: Map<T>, predicate: (value: T, key: string) => boolean) => boolean = usingNativeMaps
@@ -964,17 +945,10 @@ namespace ts {
         }
         : <T>(map: ShimMap<T>, predicate: (value: T, key: string) => boolean) => map.some(predicate);
 
-    /** Whether `predicate` is true for some key in the map. */
-    export const someKeyInMap: (map: Map<{}>, predicate: (key: string) => boolean) => boolean = usingNativeMaps
-        ? (map: ES6Map<{}>, predicate: (key: string) => boolean) => {
-            const iterator = map.keys();
-            while (true) {
-                const { value: key, done } = iterator.next();
-                if (done) return false;
-                if (predicate(key)) return true;
-            }
-        }
-        : (map: ShimMap<{}>, predicate: (key: string) => boolean) => map.someKey(predicate);
+    /** `someInMap` for just keys. */
+    export function someKeyInMap(map: Map<{}>, predicate: (key: string) => boolean): boolean {
+        return someInMap(map, (_, key) => predicate(key));
+    }
 
     /** Copy entries from `source` to `target`. */
     export function copyMapEntries<T>(source: Map<T>, target: Map<T>): void {

From 863e4d6fa06b7d705592167285f17dd12981d8e8 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 8 Dec 2016 08:00:10 -0800
Subject: [PATCH 021/159] Clean up helpers

---
 src/compiler/core.ts                          | 23 +++++++------------
 src/compiler/types.ts                         |  1 +
 .../unittests/reuseProgramStructure.ts        | 14 +++++++++++
 .../unittests/tsserverProjectSystem.ts        | 10 ++------
 4 files changed, 25 insertions(+), 23 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 3fe3b386701..3c370f7b154 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -66,7 +66,6 @@ namespace ts {
 
     /** Methods on native maps but not on shim maps. Only used in this file. */
     interface ES6Map<T> extends Map<T> {
-        readonly size: number;
         entries(): Iterator<[string, T]>;
     }
 
@@ -130,6 +129,14 @@ namespace ts {
                 return !this.some(() => true);
             }
 
+            get size(): number {
+                let size = 0;
+                for (const _ in this.data) {
+                    size++;
+                }
+                return size;
+            }
+
             forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined {
                 for (const key in this.data) {
                     const result = callback(this.data[key], key);
@@ -988,20 +995,6 @@ namespace ts {
         return true;
     }
 
-    /** True if the maps have the same keys and values. */
-    export function mapsAreEqual<T>(left: Map<T>, right: Map<T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
-        if (left === right) return true;
-        if (!left || !right) return false;
-        const someInLeftHasNoMatch = someInMap(left, (leftValue, leftKey) => {
-            if (!right.has(leftKey)) return true;
-            const rightValue = right.get(leftKey);
-            return !(valuesAreEqual ? valuesAreEqual(leftValue, rightValue) : leftValue === rightValue);
-        });
-        if (someInLeftHasNoMatch) return false;
-        const someInRightHasNoMatch = someKeyInMap(right, rightKey => !left.has(rightKey));
-        return !someInRightHasNoMatch;
-    }
-
     /**
      * Creates a map from the elements of an array.
      *
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 055049999ec..75e1e82e7f6 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -20,6 +20,7 @@ namespace ts {
         clear(): void;
         /** `key` may *not* be a string if it was set with a number and we are not using the shim. */
         forEach(action: (value: T, key: string) => void): void;
+        readonly size: number;
     }
 
     // branded string type used to store absolute, normalized and canonicalized paths
diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts
index 54c05a9c383..eb4395154e4 100644
--- a/src/harness/unittests/reuseProgramStructure.ts
+++ b/src/harness/unittests/reuseProgramStructure.ts
@@ -193,6 +193,20 @@ namespace ts {
         }
     }
 
+    /** True if the maps have the same keys and values. */
+    function mapsAreEqual<T>(left: Map<T>, right: Map<T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
+        if (left === right) return true;
+        if (!left || !right) return false;
+        const someInLeftHasNoMatch = someInMap(left, (leftValue, leftKey) => {
+            if (!right.has(leftKey)) return true;
+            const rightValue = right.get(leftKey);
+            return !(valuesAreEqual ? valuesAreEqual(leftValue, rightValue) : leftValue === rightValue);
+        });
+        if (someInLeftHasNoMatch) return false;
+        const someInRightHasNoMatch = someKeyInMap(right, rightKey => !left.has(rightKey));
+        return !someInRightHasNoMatch;
+    }
+
     function checkResolvedModulesCache(program: Program, fileName: string, expectedContent: Map<ResolvedModule>): void {
         checkCache("resolved modules", program, fileName, expectedContent, f => f.resolvedModules, checkResolvedModule);
     }
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index bec3a700879..9beefe480df 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -243,18 +243,12 @@ namespace ts.projectSystem {
     }
 
     export function checkMapKeys(caption: string, map: Map<any>, expectedKeys: string[]) {
-        assert.equal(mapSize(map), expectedKeys.length, `${caption}: incorrect size of map`);
+        assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map`);
         for (const name of expectedKeys) {
             assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${keysOfMap(map)}`);
         }
     }
 
-    function mapSize<T>(map: Map<T>): number {
-        let size = 0;
-        map.forEach(() => { size++; });
-        return size;
-    }
-
     export function checkFileNames(caption: string, actualFileNames: string[], expectedFileNames: string[]) {
         assert.equal(actualFileNames.length, expectedFileNames.length, `${caption}: incorrect actual number of files, expected ${JSON.stringify(expectedFileNames)}, got ${actualFileNames}`);
         for (const f of expectedFileNames) {
@@ -313,7 +307,7 @@ namespace ts.projectSystem {
         }
 
         count() {
-            return mapSize(this.map);
+            return this.map.size;
         }
 
         invoke() {

From 8121de74d47b6ea70a5b64375967a15727f95c90 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 8 Dec 2016 08:33:58 -0800
Subject: [PATCH 022/159] Fix target error for gulp

---
 Gulpfile.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Gulpfile.ts b/Gulpfile.ts
index 054e99c8003..7072becc2da 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -330,6 +330,7 @@ const builtGeneratedDiagnosticMessagesJSON = path.join(builtLocalDirectory, "dia
 // processDiagnosticMessages script
 gulp.task(processDiagnosticMessagesJs, false, [], () => {
     const settings: tsc.Settings = getCompilerSettings({
+        target: "es5",
         declaration: false,
         removeComments: true,
         noResolve: false,

From 8dbb8e7bf6ac861515670a86c23da6ae9275eda2 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 8 Dec 2016 08:34:56 -0800
Subject: [PATCH 023/159] Add comment

---
 src/compiler/types.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 75e1e82e7f6..ca2295e5ba2 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -11,7 +11,7 @@ namespace ts {
     /** It's allowed to get/set into a map with numbers. However, when iterating, you may get strings back due to the shim being an ordinary object (which only allows string keys). */
     export type MapKey = string | number;
 
-    /** Minimal ES6 Map interface. */
+    /** Minimal ES6 Map interface. Does not include iterators as those are hard to shim performantly. */
     export interface Map<T> {
         get(key: MapKey): T;
         has(key: MapKey): boolean;

From 5c304d0d0f3d4e08d0bd11ea48a479cbc422c417 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 12 Dec 2016 08:15:55 -0800
Subject: [PATCH 024/159] Remove `createObject`; use `Object.create` directly.

---
 src/compiler/core.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index fd9eedeeece..4ed20bcdecf 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -26,10 +26,9 @@ namespace ts {
     // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
     export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
 
-    const createObject = Object.create;
     /** Create a MapLike with good performance. Prefer this over a literal `{}`. */
     export function createMapLike<T>(): MapLike<T> {
-        const map = createObject(null); // tslint:disable-line:no-null-keyword
+        const map = Object.create(null); // tslint:disable-line:no-null-keyword
 
         // Using 'delete' on an object causes V8 to put the object in dictionary mode.
         // This disables creation of hidden classes, which are expensive when an object is

From b53b5cf4ab8f60090cc6ad764d9cfae718d3a50e Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 12 Dec 2016 08:42:12 -0800
Subject: [PATCH 025/159] Remove the "set" function and use `map.set` with
 multiple lines of code if necessary.

---
 src/compiler/binder.ts                     |  7 ++-
 src/compiler/checker.ts                    | 52 ++++++++++++++++------
 src/compiler/core.ts                       | 15 ++-----
 src/compiler/emitter.ts                    |  3 +-
 src/compiler/parser.ts                     |  6 ++-
 src/compiler/program.ts                    | 10 +++--
 src/compiler/transformers/module/module.ts |  3 +-
 src/compiler/transformers/module/system.ts |  6 ++-
 src/compiler/tsc.ts                        |  7 ++-
 src/compiler/utilities.ts                  |  4 +-
 src/harness/harness.ts                     |  8 ++--
 src/server/client.ts                       |  3 +-
 src/services/patternMatcher.ts             |  6 ++-
 src/services/services.ts                   |  6 ++-
 14 files changed, 91 insertions(+), 45 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 18a6d00e922..046b67ccd1c 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -349,7 +349,10 @@ namespace ts {
                 // Otherwise, we'll be merging into a compatible existing symbol (for example when
                 // you have multiple 'vars' with the same name in the same container).  In this case
                 // just add this node into the declarations list of the symbol.
-                symbol = symbolTable.get(name) || set(symbolTable, name, createSymbol(SymbolFlags.None, name));
+                symbol = symbolTable.get(name);
+                if (!symbol) {
+                    symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));
+                }
 
                 if (name && (includes & SymbolFlags.Classifiable)) {
                     classifiableNames.set(name, name);
@@ -359,7 +362,7 @@ namespace ts {
                     if (symbol.isReplaceableByMethod) {
                         // Javascript constructor-declared symbols can be discarded in favor of
                         // prototype symbols like methods.
-                        symbol = set(symbolTable, name, createSymbol(SymbolFlags.None, name));
+                        symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));
                     }
                     else {
                         if (node.name) {
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6bbbab8822e..2394d5017a3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4062,7 +4062,8 @@ namespace ts {
                                 const memberSymbol = getSymbolOfNode(member);
                                 const value = getEnumMemberValue(member);
                                 if (!memberTypes.has(value)) {
-                                    const memberType = set(memberTypes, value, createEnumLiteralType(memberSymbol, enumType, "" + value));
+                                    const memberType = createEnumLiteralType(memberSymbol, enumType, "" + value);
+                                    memberTypes.set(value, memberType);
                                     memberTypeList.push(memberType);
                                 }
                             }
@@ -5192,7 +5193,11 @@ namespace ts {
         function getSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
             const instantiations = signature.instantiations || (signature.instantiations = createMap<Signature>());
             const id = getTypeListId(typeArguments);
-            return instantiations.get(id) || set(instantiations, id, createSignatureInstantiation(signature, typeArguments));
+            let instantiation = instantiations.get(id);
+            if (!instantiation) {
+                instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments));
+            }
+            return instantiation;
         }
 
         function createSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
@@ -5348,7 +5353,8 @@ namespace ts {
             const id = getTypeListId(typeArguments);
             let type = target.instantiations.get(id);
             if (!type) {
-                type = set(target.instantiations, id, <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol));
+                type = <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol);
+                target.instantiations.set(id, type);
                 type.flags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
                 type.target = target;
                 type.typeArguments = typeArguments;
@@ -5395,7 +5401,11 @@ namespace ts {
             const links = getSymbolLinks(symbol);
             const typeParameters = links.typeParameters;
             const id = getTypeListId(typeArguments);
-            return links.instantiations.get(id) || set(links.instantiations, id, instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
+            let instantiation = links.instantiations.get(id);
+            if (!instantiation) {
+                links.instantiations.set(id, instantiation = instantiateTypeNoAlias(type, createTypeMapper(typeParameters, typeArguments)));
+            }
+            return instantiation;
         }
 
         // Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include
@@ -5844,7 +5854,8 @@ namespace ts {
             let type = unionTypes.get(id);
             if (!type) {
                 const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
-                type = set(unionTypes, id, <UnionType>createType(TypeFlags.Union | propagatedFlags));
+                type = <UnionType>createType(TypeFlags.Union | propagatedFlags);
+                unionTypes.set(id, type);
                 type.types = types;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
@@ -5918,7 +5929,8 @@ namespace ts {
             let type = intersectionTypes.get(id);
             if (!type) {
                 const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
-                type = set(intersectionTypes, id, <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags));
+                type = <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags);
+                intersectionTypes.set(id, type);
                 type.types = typeSet;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
@@ -6100,7 +6112,11 @@ namespace ts {
                 }
                 // Otherwise we defer the operation by creating an indexed access type.
                 const id = objectType.id + "," + indexType.id;
-                return indexedAccessTypes.get(id) || set(indexedAccessTypes, id, createIndexedAccessType(objectType, indexType));
+                let type = indexedAccessTypes.get(id);
+                if (!type) {
+                    indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType));
+                }
+                return type;
             }
             // In the following we resolve T[K] to the type of the property in T selected by K.
             const apparentObjectType = getApparentType(objectType);
@@ -6268,7 +6284,11 @@ namespace ts {
 
         function getLiteralTypeForText(flags: TypeFlags, text: string) {
             const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes;
-            return map.get(text) || set(map, text, createLiteralType(flags, text));
+            let type = map.get(text);
+            if (!type) {
+                map.set(text, type = createLiteralType(flags, text));
+            }
+            return type;
         }
 
         function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
@@ -7060,7 +7080,8 @@ namespace ts {
             if (source.symbol.name !== target.symbol.name ||
                 !(source.symbol.flags & SymbolFlags.RegularEnum) || !(target.symbol.flags & SymbolFlags.RegularEnum) ||
                 (source.flags & TypeFlags.Union) !== (target.flags & TypeFlags.Union)) {
-                return set(enumRelation, id, false);
+                enumRelation.set(id, false);
+                return false;
             }
             const targetEnumType = getTypeOfSymbol(target.symbol);
             for (const property of getPropertiesOfType(getTypeOfSymbol(source.symbol))) {
@@ -7071,11 +7092,13 @@ namespace ts {
                             errorReporter(Diagnostics.Property_0_is_missing_in_type_1, property.name,
                                 typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
                         }
-                        return set(enumRelation, id, false);
+                        enumRelation.set(id, false);
+                        return false;
                     }
                 }
             }
-            return set(enumRelation, id, true);
+            enumRelation.set(id, true);
+            return true;
         }
 
         function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
@@ -9815,7 +9838,8 @@ namespace ts {
                 if (isIncomplete(firstAntecedentType)) {
                     return createFlowType(result, /*incomplete*/ true);
                 }
-                return set(cache, key, result);
+                cache.set(key, result);
+                return result;
             }
 
             function isMatchingReferenceDiscriminant(expr: Expression) {
@@ -11771,9 +11795,9 @@ namespace ts {
         }
 
         function getJsxType(name: string) {
-            const jsxType = jsxTypes.get(name);
+            let jsxType = jsxTypes.get(name);
             if (jsxType === undefined) {
-                return set(jsxTypes, name, getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType);
+                jsxTypes.set(name, jsxType = getExportedTypeFromNamespace(JsxNames.JSX, name) || unknownType);
             }
             return jsxType;
         }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 4ed20bcdecf..6239dc93146 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -156,15 +156,6 @@ namespace ts {
         }
     }
 
-    /**
-     * Unlike `map.set(key, value)`, this returns the value, making it useful as an expression.
-     * Prefer `map.set(key, value)` for statements.
-     */
-    export function set<T>(map: Map<T>, key: MapKey, value: T): T {
-        map.set(key, value);
-        return value;
-    }
-
     export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
         const files = createMap<T>();
         return {
@@ -1050,14 +1041,14 @@ namespace ts {
      * Creates the array if it does not already exist.
      */
     export function multiMapAdd<V>(map: Map<V[]>, key: string | number, value: V): V[] {
-        const values = map.get(key);
+        let values = map.get(key);
         if (values) {
             values.push(value);
-            return values;
         }
         else {
-            return set(map, key, [value]);
+            map.set(key, values = [value]);
         }
+        return values;
     }
 
     /**
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 191a39a5797..00144f2d00b 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2545,7 +2545,8 @@ namespace ts {
             while (true) {
                 const generatedName = baseName + i;
                 if (isUniqueName(generatedName)) {
-                    return set(generatedNameSet, generatedName, generatedName);
+                    generatedNameSet.set(generatedName, generatedName);
+                    return generatedName;
                 }
                 i++;
             }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 3da9093ee5a..bb53eeba0e0 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1131,7 +1131,11 @@ namespace ts {
 
         function internIdentifier(text: string): string {
             text = escapeIdentifier(text);
-            return identifiers.get(text) || set(identifiers, text, text);
+            let identifier = identifiers.get(text);
+            if (identifier === undefined) {
+                identifiers.set(text, identifier = text);
+            }
+            return identifier;
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 3da9f57ca39..ab04a21ee69 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -277,9 +277,13 @@ namespace ts {
         const resolutions: T[] = [];
         const cache = createMap<T>();
         for (const name of names) {
-            const result = cache.has(name)
-                ? cache.get(name)
-                : set(cache, name, loader(name, containingFile));
+            let result: T;
+            if (cache.has(name)) {
+                result = cache.get(name);
+            }
+            else {
+                cache.set(name, result = loader(name, containingFile));
+            }
             resolutions.push(result);
         }
         return resolutions;
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index 2e926406fb4..5d05667e4c2 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -60,7 +60,8 @@ namespace ts {
             }
 
             currentSourceFile = node;
-            currentModuleInfo = set(moduleInfoMap, getOriginalNodeId(node), collectExternalModuleInfo(node, resolver, compilerOptions));
+            currentModuleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
+            moduleInfoMap.set(getOriginalNodeId(node), currentModuleInfo);
 
             // Perform the transformation.
             const transformModule = transformModuleDelegates.get(moduleKind) || transformModuleDelegates.get(ModuleKind.None);
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 8d1e1749c0b..bc613bcfaf6 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -73,11 +73,13 @@ namespace ts {
             // see comment to 'substitutePostfixUnaryExpression' for more details
 
             // Collect information about the external module and dependency groups.
-            moduleInfo = set(moduleInfoMap, id, collectExternalModuleInfo(node, resolver, compilerOptions));
+            moduleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
+            moduleInfoMap.set(id, moduleInfo);
 
             // Make sure that the name of the 'exports' function does not conflict with
             // existing identifiers.
-            exportFunction = set(exportFunctionsMap, id, createUniqueName("exports"));
+            exportFunction = createUniqueName("exports");
+            exportFunctionsMap.set(id, exportFunction);
             contextObject = createUniqueName("context");
 
             // Add the body of the module.
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index 0e66ccb14b8..5de16a20fc2 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -378,8 +378,11 @@ namespace ts {
         }
 
         function cachedFileExists(fileName: string): boolean {
-            const fileExists = cachedExistingFiles.get(fileName);
-            return fileExists !== undefined ? fileExists : set(cachedExistingFiles, fileName, hostFileExists(fileName));
+            let fileExists = cachedExistingFiles.get(fileName);
+            if (fileExists === undefined) {
+                cachedExistingFiles.set(fileName, fileExists = hostFileExists(fileName));
+            }
+            return fileExists;
         }
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 94b0fa20987..25973cae5cb 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3323,7 +3323,9 @@ namespace ts {
 
             for (const name in syntaxKindEnum) {
                 if (syntaxKindEnum[name] === kind) {
-                    return set(syntaxKindCache, kind, kind.toString() + " (" + name + ")");
+                    const result = `${kind} (${name})`;
+                    syntaxKindCache.set(kind, result);
+                    return result;
                 }
             }
         }
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 265fe4c142c..c94a9360745 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -918,9 +918,11 @@ namespace Harness {
                 return undefined;
             }
 
-            const sourceFile = libFileNameSourceFileMap.get(fileName);
-            return sourceFile || ts.set(libFileNameSourceFileMap, fileName,
-                createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest));
+            let sourceFile = libFileNameSourceFileMap.get(fileName);
+            if (!sourceFile) {
+                libFileNameSourceFileMap.set(fileName, sourceFile = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest));
+            }
+            return sourceFile;
         }
 
         export function getDefaultLibFileName(options: ts.CompilerOptions): string {
diff --git a/src/server/client.ts b/src/server/client.ts
index 13d16073d1c..d9e93769bd9 100644
--- a/src/server/client.ts
+++ b/src/server/client.ts
@@ -34,7 +34,8 @@ namespace ts.server {
             let lineMap = this.lineMaps.get(fileName);
             if (!lineMap) {
                 const scriptSnapshot = this.host.getScriptSnapshot(fileName);
-                lineMap = set(this.lineMaps, fileName, ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength())));
+                lineMap = ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength()));
+                this.lineMaps.set(fileName, lineMap);
             }
             return lineMap;
         }
diff --git a/src/services/patternMatcher.ts b/src/services/patternMatcher.ts
index b8941ef3147..940290a2f94 100644
--- a/src/services/patternMatcher.ts
+++ b/src/services/patternMatcher.ts
@@ -188,7 +188,11 @@ namespace ts {
         }
 
         function getWordSpans(word: string): TextSpan[] {
-            return stringToWordSpans.get(word) || set(stringToWordSpans, word, breakIntoWordSpans(word));
+            let spans = stringToWordSpans.get(word);
+            if (!spans) {
+                stringToWordSpans.set(word, spans = breakIntoWordSpans(word));
+            }
+            return spans;
         }
 
         function matchTextChunk(candidate: string, chunk: TextChunk, punctuationStripped: boolean): PatternMatch {
diff --git a/src/services/services.ts b/src/services/services.ts
index 87ae9fb8561..6d0d384bcdd 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -532,7 +532,11 @@ namespace ts {
             }
 
             function getDeclarations(name: string) {
-                return result.get(name) || set(result, name, []);
+                let declarations = result.get(name);
+                if (!declarations) {
+                    result.set(name, declarations = []);
+                }
+                return declarations;
             }
 
             function getDeclarationName(declaration: Declaration) {

From 8386d491abacdf2f43aacace0efcaa37b27b748d Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 27 Dec 2016 11:17:33 -0800
Subject: [PATCH 026/159] Use sparse arrays for number-keyed maps

---
 src/compiler/checker.ts                       |   9 +-
 src/compiler/core.ts                          |  36 +++---
 src/compiler/factory.ts                       |  30 ++---
 src/compiler/sourcemap.ts                     |   2 +-
 src/compiler/transformer.ts                   |  22 ++--
 src/compiler/transformers/generators.ts       |  28 ++---
 src/compiler/transformers/module/module.ts    |  55 ++++-----
 src/compiler/transformers/module/system.ts    |  53 +++++----
 src/compiler/transformers/ts.ts               |  14 +--
 src/compiler/tsc.ts                           |  16 +--
 src/compiler/types.ts                         |  22 ++--
 src/compiler/utilities.ts                     |   6 +-
 src/compiler/visitor.ts                       | 104 +++++++++---------
 src/harness/unittests/session.ts              |  10 +-
 .../unittests/tsserverProjectSystem.ts        |  22 ++--
 src/services/codefixes/codeFixProvider.ts     |  10 +-
 src/services/codefixes/importFixes.ts         |  22 ++--
 17 files changed, 240 insertions(+), 221 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2394d5017a3..47a7db16986 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4054,16 +4054,15 @@ namespace ts {
                 enumType.symbol = symbol;
                 if (enumHasLiteralMembers(symbol)) {
                     const memberTypeList: Type[] = [];
-                    const memberTypes = createMap<EnumLiteralType>();
+                    const memberTypes = sparseArray<EnumLiteralType>();
                     for (const declaration of enumType.symbol.declarations) {
                         if (declaration.kind === SyntaxKind.EnumDeclaration) {
                             computeEnumMemberValues(<EnumDeclaration>declaration);
                             for (const member of (<EnumDeclaration>declaration).members) {
                                 const memberSymbol = getSymbolOfNode(member);
                                 const value = getEnumMemberValue(member);
-                                if (!memberTypes.has(value)) {
-                                    const memberType = createEnumLiteralType(memberSymbol, enumType, "" + value);
-                                    memberTypes.set(value, memberType);
+                                if (!memberTypes[value]) {
+                                    const memberType = memberTypes[value] = createEnumLiteralType(memberSymbol, enumType, "" + value);
                                     memberTypeList.push(memberType);
                                 }
                             }
@@ -4085,7 +4084,7 @@ namespace ts {
             if (!links.declaredType) {
                 const enumType = <EnumType>getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
                 links.declaredType = enumType.flags & TypeFlags.Union ?
-                    enumType.memberTypes.get(getEnumMemberValue(<EnumMember>symbol.valueDeclaration)) :
+                    enumType.memberTypes[getEnumMemberValue(<EnumMember>symbol.valueDeclaration)] :
                     enumType;
             }
             return links.declaredType;
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 6239dc93146..36847796b6e 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -39,6 +39,8 @@ namespace ts {
         return map;
     }
 
+    export const sparseArray: <T>() => SparseArray<T> = createMapLike;
+
     /** Create a new map. If a template object is provided, the map will copy entries from it. */
     export function createMap<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = new MapCtr<T>();
@@ -52,17 +54,6 @@ namespace ts {
         return map;
     }
 
-    /** Create a map from [key, value] pairs. This avoids casting keys to strings. */
-    export function createMapFromPairs<T>(...pairs: [number, T][]): Map<T> {
-        const map: Map<T> = new MapCtr<T>();
-
-        for (const [key, value] of pairs) {
-            map.set(key, value);
-        }
-
-        return map;
-    }
-
     /** Methods on native maps but not on shim maps. Only used in this file. */
     interface ES6Map<T> extends Map<T> {
         entries(): Iterator<[string, T]>;
@@ -92,21 +83,21 @@ namespace ts {
         return class<T> implements ShimMap<T> {
             private data = createMapLike<T>();
 
-            get(key: MapKey): T {
+            get(key: string): T {
                 return this.data[key];
             }
 
-            set(key: MapKey, value: T): this {
+            set(key: string, value: T): this {
                 this.data[key] = value;
                 return this;
             }
 
-            has(key: MapKey): boolean {
+            has(key: string): boolean {
                 // tslint:disable-next-line:no-in-operator
                 return key in this.data;
             }
 
-            delete(key: MapKey): boolean {
+            delete(key: string): boolean {
                 const had = this.has(key);
                 if (had) {
                     delete this.data[key];
@@ -890,7 +881,7 @@ namespace ts {
      * Array of every key in a map.
      * May not actually return string[] if numbers were put into the map.
      */
-    export function keysOfMap<T>(map: Map<T>): string[] {
+    export function keysOfMap(map: Map<{}>): string[] {
         const keys: string[] = [];
         forEachKeyInMap(map, key => {
             keys.push(key);
@@ -1040,7 +1031,7 @@ namespace ts {
      * Adds the value to an array of values associated with the key, and returns the array.
      * Creates the array if it does not already exist.
      */
-    export function multiMapAdd<V>(map: Map<V[]>, key: string | number, value: V): V[] {
+    export function multiMapAdd<V>(map: Map<V[]>, key: string, value: V): V[] {
         let values = map.get(key);
         if (values) {
             values.push(value);
@@ -1051,6 +1042,17 @@ namespace ts {
         return values;
     }
 
+    export function multiMapSparseArrayAdd<V>(map: SparseArray<V[]>, key: number, value: V): V[] {
+        let values = map[key];
+        if (values) {
+            values.push(value);
+        }
+        else {
+            map[key] = values = [value];
+        }
+        return values;
+    }
+
     /**
      * Removes a value from an array of values associated with the key.
      * Does not preserve the order of those values.
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 2ef73dea727..15a946648b1 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -1,4 +1,4 @@
-/// <reference path="core.ts"/>
+/// <reference path="core.ts"/>
 /// <reference path="utilities.ts"/>
 
 /* @internal */
@@ -2641,9 +2641,11 @@ namespace ts {
         return destEmitNode;
     }
 
-    function mergeTokenSourceMapRanges(sourceRanges: Map<TextRange>, destRanges: Map<TextRange>) {
-        if (!destRanges) destRanges = createMap<TextRange>();
-        copyMapEntries(sourceRanges, destRanges);
+    function mergeTokenSourceMapRanges(sourceRanges: SparseArray<TextRange>, destRanges: SparseArray<TextRange>) {
+        if (!destRanges) destRanges = [];
+        for (const key in sourceRanges) {
+            destRanges[key] = sourceRanges[key];
+        }
         return destRanges;
     }
 
@@ -2745,7 +2747,7 @@ namespace ts {
     export function getTokenSourceMapRange(node: Node, token: SyntaxKind) {
         const emitNode = node.emitNode;
         const tokenSourceMapRanges = emitNode && emitNode.tokenSourceMapRanges;
-        return tokenSourceMapRanges && tokenSourceMapRanges.get(token);
+        return tokenSourceMapRanges && tokenSourceMapRanges[token];
     }
 
     /**
@@ -2757,8 +2759,8 @@ namespace ts {
      */
     export function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: TextRange) {
         const emitNode = getOrCreateEmitNode(node);
-        const tokenSourceMapRanges = emitNode.tokenSourceMapRanges || (emitNode.tokenSourceMapRanges = createMap<TextRange>());
-        tokenSourceMapRanges.set(token, range);
+        const tokenSourceMapRanges = emitNode.tokenSourceMapRanges || (emitNode.tokenSourceMapRanges = []);
+        tokenSourceMapRanges[token] = range;
         return node;
     }
 
@@ -3270,7 +3272,7 @@ namespace ts {
         externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[]; // imports of other external modules
         externalHelpersImportDeclaration: ImportDeclaration | undefined; // import of external helpers
         exportSpecifiers: Map<ExportSpecifier[]>; // export specifiers by name
-        exportedBindings: Map<Identifier[]>; // exported names of local declarations
+        exportedBindings: SparseArray<Identifier[]>; // exported names of local declarations
         exportedNames: Identifier[]; // all exported names local to module
         exportEquals: ExportAssignment | undefined; // an export= declaration if one was present
         hasExportStarsToExportValues: boolean; // whether this module contains export*
@@ -3279,7 +3281,7 @@ namespace ts {
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver, compilerOptions: CompilerOptions): ExternalModuleInfo {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
         const exportSpecifiers = createMap<ExportSpecifier[]>();
-        const exportedBindings = createMap<Identifier[]>();
+        const exportedBindings = sparseArray<Identifier[]>();
         const uniqueExports = createMap<boolean>();
         let exportedNames: Identifier[];
         let hasExportDefault = false;
@@ -3338,7 +3340,7 @@ namespace ts {
                                     || resolver.getReferencedValueDeclaration(name);
 
                                 if (decl) {
-                                    multiMapAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
+                                    multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
                                 }
 
                                 uniqueExports.set(specifier.name.text, true);
@@ -3368,7 +3370,7 @@ namespace ts {
                         if (hasModifier(node, ModifierFlags.Default)) {
                             // export default function() { }
                             if (!hasExportDefault) {
-                                multiMapAdd(exportedBindings, getOriginalNodeId(node), getDeclarationName(<FunctionDeclaration>node));
+                                multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), getDeclarationName(<FunctionDeclaration>node));
                                 hasExportDefault = true;
                             }
                         }
@@ -3376,7 +3378,7 @@ namespace ts {
                             // export function x() { }
                             const name = (<FunctionDeclaration>node).name;
                             if (!uniqueExports.get(name.text)) {
-                                multiMapAdd(exportedBindings, getOriginalNodeId(node), name);
+                                multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
                                 uniqueExports.set(name.text, true);
                                 exportedNames = append(exportedNames, name);
                             }
@@ -3389,7 +3391,7 @@ namespace ts {
                         if (hasModifier(node, ModifierFlags.Default)) {
                             // export default class { }
                             if (!hasExportDefault) {
-                                multiMapAdd(exportedBindings, getOriginalNodeId(node), getDeclarationName(<ClassDeclaration>node));
+                                multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), getDeclarationName(<ClassDeclaration>node));
                                 hasExportDefault = true;
                             }
                         }
@@ -3397,7 +3399,7 @@ namespace ts {
                             // export class x { }
                             const name = (<ClassDeclaration>node).name;
                             if (!uniqueExports.get(name.text)) {
-                                multiMapAdd(exportedBindings, getOriginalNodeId(node), name);
+                                multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
                                 uniqueExports.set(name.text, true);
                                 exportedNames = append(exportedNames, name);
                             }
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index a814a91c355..650b9b0ef02 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -362,7 +362,7 @@ namespace ts {
 
             const emitNode = node && node.emitNode;
             const emitFlags = emitNode && emitNode.flags;
-            const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges.get(token);
+            const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
 
             tokenPos = skipTrivia(currentSourceText, range ? range.pos : tokenPos);
             if ((emitFlags & EmitFlags.NoTokenLeadingSourceMaps) === 0 && tokenPos >= 0) {
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index 1440481d38e..cef8c701455 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -1,4 +1,4 @@
-/// <reference path="visitor.ts" />
+/// <reference path="visitor.ts" />
 /// <reference path="transformers/ts.ts" />
 /// <reference path="transformers/jsx.ts" />
 /// <reference path="transformers/esnext.ts" />
@@ -13,14 +13,16 @@
 
 /* @internal */
 namespace ts {
-    const moduleTransformerMap = createMapFromPairs<Transformer>(
-        [ModuleKind.ES2015, transformES2015Module],
-        [ModuleKind.System, transformSystemModule],
-        [ModuleKind.AMD, transformModule],
-        [ModuleKind.CommonJS, transformModule],
-        [ModuleKind.UMD, transformModule],
-        [ModuleKind.None, transformModule],
-    );
+    function getModuleTransformer(moduleKind: ModuleKind): Transformer {
+        switch (moduleKind) {
+            case ModuleKind.ES2015:
+                return transformES2015Module;
+            case ModuleKind.System:
+                return transformSystemModule;
+            default:
+                return transformModule;
+        }
+    }
 
     const enum SyntaxKindFeatureFlags {
         Substitution = 1 << 0,
@@ -56,7 +58,7 @@ namespace ts {
             transformers.push(transformGenerators);
         }
 
-        transformers.push(moduleTransformerMap.get(moduleKind) || moduleTransformerMap.get(ModuleKind.None));
+        transformers.push(getModuleTransformer(moduleKind));
 
         // The ES5 transformer is last so that it can substitute expressions like `exports.default`
         // for ES3.
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 0b853649e81..85aba96387b 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -1,4 +1,4 @@
-/// <reference path="../factory.ts" />
+/// <reference path="../factory.ts" />
 /// <reference path="../visitor.ts" />
 
 // Transforms generator functions into a compatible ES5 representation with similar runtime
@@ -217,13 +217,15 @@ namespace ts {
         Endfinally = 7,
     }
 
-    const instructionNames = createMapFromPairs<string>(
-        [Instruction.Return, "return"],
-        [Instruction.Break, "break"],
-        [Instruction.Yield, "yield"],
-        [Instruction.YieldStar, "yield*"],
-        [Instruction.Endfinally, "endfinally"],
-    );
+    function getInstructionName(instruction: Instruction): string {
+        switch (instruction) {
+            case Instruction.Return: return "return";
+            case Instruction.Break: return "break";
+            case Instruction.Yield: return "yield";
+            case Instruction.YieldStar: return "yield*";
+            case Instruction.Endfinally: return "endfinally";
+        }
+    }
 
     export function transformGenerators(context: TransformationContext) {
         const {
@@ -241,7 +243,7 @@ namespace ts {
 
         let currentSourceFile: SourceFile;
         let renamedCatchVariables: Map<boolean>;
-        let renamedCatchVariableDeclarations: Map<Identifier>;
+        let renamedCatchVariableDeclarations: SparseArray<Identifier>;
 
         let inGeneratorFunctionBody: boolean;
         let inStatementContainingYield: boolean;
@@ -1926,7 +1928,7 @@ namespace ts {
                 if (isIdentifier(original) && original.parent) {
                     const declaration = resolver.getReferencedValueDeclaration(original);
                     if (declaration) {
-                        const name = renamedCatchVariableDeclarations.get(getOriginalNodeId(declaration));
+                        const name = renamedCatchVariableDeclarations[getOriginalNodeId(declaration)];
                         if (name) {
                             const clone = getMutableClone(name);
                             setSourceMapRange(clone, node);
@@ -2092,12 +2094,12 @@ namespace ts {
 
             if (!renamedCatchVariables) {
                 renamedCatchVariables = createMap<boolean>();
-                renamedCatchVariableDeclarations = createMap<Identifier>();
+                renamedCatchVariableDeclarations = sparseArray<Identifier>();
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
 
             renamedCatchVariables.set(text, true);
-            renamedCatchVariableDeclarations.set(getOriginalNodeId(variable), name);
+            renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name;
 
             const exception = <ExceptionBlock>peekBlock();
             Debug.assert(exception.state < ExceptionBlockState.Catch);
@@ -2401,7 +2403,7 @@ namespace ts {
          */
         function createInstruction(instruction: Instruction): NumericLiteral {
             const literal = createLiteral(instruction);
-            literal.trailingComment = instructionNames.get(instruction);
+            literal.trailingComment = getInstructionName(instruction);
             return literal;
         }
 
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index 5d05667e4c2..e5e27c8360d 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -1,4 +1,4 @@
-/// <reference path="../../factory.ts" />
+/// <reference path="../../factory.ts" />
 /// <reference path="../../visitor.ts" />
 
 /*@internal*/
@@ -10,12 +10,13 @@ namespace ts {
             importAliasNames: ParameterDeclaration[];
         }
 
-        const transformModuleDelegates = createMapFromPairs<(node: SourceFile) => SourceFile>(
-            [ModuleKind.None, transformCommonJSModule],
-            [ModuleKind.CommonJS, transformCommonJSModule],
-            [ModuleKind.AMD, transformAMDModule],
-            [ModuleKind.UMD, transformUMDModule],
-        );
+        function getTransformModuleDelegate(moduleKind: ModuleKind): (node: SourceFile) => SourceFile {
+            switch (moduleKind) {
+                case ModuleKind.AMD: return transformAMDModule;
+                case ModuleKind.UMD: return transformUMDModule;
+                default: return transformCommonJSModule;
+            }
+        }
 
         const {
             startLexicalEnvironment,
@@ -38,12 +39,12 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.ShorthandPropertyAssignment); // Substitutes shorthand property assignments for imported/exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap = createMap<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
-        const deferredExports = createMap<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
+        const moduleInfoMap = sparseArray<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
+        const deferredExports = sparseArray<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
 
         let currentSourceFile: SourceFile; // The current file.
         let currentModuleInfo: ExternalModuleInfo; // The ExternalModuleInfo for the current file.
-        let noSubstitution: Map<boolean>; // Set of nodes for which substitution rules should be ignored.
+        let noSubstitution: SparseArray<boolean>; // Set of nodes for which substitution rules should be ignored.
 
         return transformSourceFile;
 
@@ -61,10 +62,10 @@ namespace ts {
 
             currentSourceFile = node;
             currentModuleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
-            moduleInfoMap.set(getOriginalNodeId(node), currentModuleInfo);
+            moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo;
 
             // Perform the transformation.
-            const transformModule = transformModuleDelegates.get(moduleKind) || transformModuleDelegates.get(ModuleKind.None);
+            const transformModule = getTransformModuleDelegate(moduleKind);
             const updated = transformModule(node);
 
             currentSourceFile = undefined;
@@ -445,7 +446,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfImportDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfImportDeclaration(statements, node);
@@ -524,7 +525,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfImportEqualsDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfImportEqualsDeclaration(statements, node);
@@ -611,7 +612,7 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportStatement(deferredExports.get(id), createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true));
+                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
             }
             else {
                 statements = appendExportStatement(statements, createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
@@ -652,7 +653,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -691,7 +692,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -742,7 +743,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfVariableStatement(statements, node);
@@ -795,7 +796,7 @@ namespace ts {
             // statement.
             if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === SyntaxKind.VariableStatement) {
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), <VariableStatement>node.original));
+                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], <VariableStatement>node.original);
             }
 
             return node;
@@ -821,9 +822,9 @@ namespace ts {
             // end of the transformed declaration. We use this marker to emit any deferred exports
             // of the declaration.
             const id = getOriginalNodeId(node);
-            const statements = deferredExports.get(id);
+            const statements = deferredExports[id];
             if (statements) {
-                deferredExports.delete(id);
+                delete deferredExports[id];
                 return append(statements, node);
             }
 
@@ -1103,8 +1104,8 @@ namespace ts {
         function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
             if (node.kind === SyntaxKind.SourceFile) {
                 currentSourceFile = <SourceFile>node;
-                currentModuleInfo = moduleInfoMap.get(getOriginalNodeId(currentSourceFile));
-                noSubstitution = createMap<boolean>();
+                currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
+                noSubstitution = sparseArray<boolean>();
 
                 previousOnEmitNode(emitContext, node, emitCallback);
 
@@ -1129,7 +1130,7 @@ namespace ts {
          */
         function onSubstituteNode(emitContext: EmitContext, node: Node) {
             node = previousOnSubstituteNode(emitContext, node);
-            if (node.id && noSubstitution.get(node.id)) {
+            if (node.id && noSubstitution[node.id]) {
                 return node;
             }
 
@@ -1255,7 +1256,7 @@ namespace ts {
                     let expression: Expression = node;
                     for (const exportName of exportedNames) {
                         // Mark the node to prevent triggering this rule again.
-                        noSubstitution.set(getNodeId(expression), true);
+                        noSubstitution[getNodeId(expression)] = true;
                         expression = createExportExpression(exportName, expression, /*location*/ node);
                     }
 
@@ -1297,7 +1298,7 @@ namespace ts {
                         : node;
                     for (const exportName of exportedNames) {
                         // Mark the node to prevent triggering this rule again.
-                        noSubstitution.set(getNodeId(expression), true);
+                        noSubstitution[getNodeId(expression)] = true;
                         expression = createExportExpression(exportName, expression);
                     }
 
@@ -1319,7 +1320,7 @@ namespace ts {
                     || resolver.getReferencedValueDeclaration(name);
                 if (valueDeclaration) {
                     return currentModuleInfo
-                        && currentModuleInfo.exportedBindings.get(getOriginalNodeId(valueDeclaration));
+                        && currentModuleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)];
                 }
             }
         }
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index bc613bcfaf6..c20e6b5cf32 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -1,4 +1,4 @@
-/// <reference path="../../factory.ts" />
+/// <reference path="../../factory.ts" />
 /// <reference path="../../visitor.ts" />
 
 /*@internal*/
@@ -28,10 +28,10 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.PostfixUnaryExpression); // Substitutes updates to exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap = createMap<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
-        const deferredExports = createMap<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
-        const exportFunctionsMap = createMap<Identifier>(); // The export function associated with a source file.
-        const noSubstitutionMap = createMap<Map<boolean>>(); // Set of nodes for which substitution rules should be ignored for each file.
+        const moduleInfoMap = sparseArray<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
+        const deferredExports = sparseArray<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
+        const exportFunctionsMap = sparseArray<Identifier>(); // The export function associated with a source file.
+        const noSubstitutionMap = sparseArray<SparseArray<boolean>>(); // Set of nodes for which substitution rules should be ignored for each file.
 
         let currentSourceFile: SourceFile; // The current file.
         let moduleInfo: ExternalModuleInfo; // ExternalModuleInfo for the current file.
@@ -39,7 +39,7 @@ namespace ts {
         let contextObject: Identifier; // The context object for the current file.
         let hoistedStatements: Statement[];
         let enclosingBlockScopedContainer: Node;
-        let noSubstitution: Map<boolean>; // Set of nodes for which substitution rules should be ignored.
+        let noSubstitution: SparseArray<boolean>; // Set of nodes for which substitution rules should be ignored.
 
         return transformSourceFile;
 
@@ -73,13 +73,12 @@ namespace ts {
             // see comment to 'substitutePostfixUnaryExpression' for more details
 
             // Collect information about the external module and dependency groups.
-            moduleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);
-            moduleInfoMap.set(id, moduleInfo);
+            moduleInfo = moduleInfoMap[id] = collectExternalModuleInfo(node, resolver, compilerOptions);
 
             // Make sure that the name of the 'exports' function does not conflict with
             // existing identifiers.
             exportFunction = createUniqueName("exports");
-            exportFunctionsMap.set(id, exportFunction);
+            exportFunctionsMap[id] = exportFunction;
             contextObject = createUniqueName("context");
 
             // Add the body of the module.
@@ -123,7 +122,7 @@ namespace ts {
             }
 
             if (noSubstitution) {
-                noSubstitutionMap.set(id, noSubstitution);
+                noSubstitutionMap[id] = noSubstitution;
                 noSubstitution = undefined;
             }
 
@@ -610,7 +609,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfImportDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfImportDeclaration(statements, node);
@@ -633,7 +632,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfImportEqualsDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfImportEqualsDeclaration(statements, node);
@@ -658,7 +657,7 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportStatement(deferredExports.get(id), createIdentifier("default"), expression, /*allowComments*/ true));
+                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), expression, /*allowComments*/ true);
             }
             else {
                 return createExportStatement(createIdentifier("default"), expression, /*allowComments*/ true);
@@ -690,7 +689,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
             }
             else {
                 hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node);
@@ -732,7 +731,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfHoistedDeclaration(deferredExports.get(id), node));
+                deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfHoistedDeclaration(statements, node);
@@ -772,7 +771,7 @@ namespace ts {
             if (isMarkedDeclaration) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), node, isExportedDeclaration));
+                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration);
             }
             else {
                 statements = appendExportsOfVariableStatement(statements, node, /*exportSelf*/ false);
@@ -885,7 +884,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === SyntaxKind.VariableStatement) {
                 const id = getOriginalNodeId(node);
                 const isExportedDeclaration = hasModifier(node.original, ModifierFlags.Export);
-                deferredExports.set(id, appendExportsOfVariableStatement(deferredExports.get(id), <VariableStatement>node.original, isExportedDeclaration));
+                deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], <VariableStatement>node.original, isExportedDeclaration);
             }
 
             return node;
@@ -911,9 +910,9 @@ namespace ts {
             // end of the transformed declaration. We use this marker to emit any deferred exports
             // of the declaration.
             const id = getOriginalNodeId(node);
-            const statements = deferredExports.get(id);
+            const statements = deferredExports[id];
             if (statements) {
-                deferredExports.delete(id);
+                delete deferredExports[id];
                 return append(statements, node);
             }
 
@@ -1556,12 +1555,12 @@ namespace ts {
             if (node.kind === SyntaxKind.SourceFile) {
                 const id = getOriginalNodeId(node);
                 currentSourceFile = <SourceFile>node;
-                moduleInfo = moduleInfoMap.get(id);
-                exportFunction = exportFunctionsMap.get(id);
-                noSubstitution = noSubstitutionMap.get(id);
+                moduleInfo = moduleInfoMap[id];
+                exportFunction = exportFunctionsMap[id];
+                noSubstitution = noSubstitutionMap[id];
 
                 if (noSubstitution) {
-                    noSubstitutionMap.delete(id);
+                    delete noSubstitutionMap[id];
                 }
 
                 previousOnEmitNode(emitContext, node, emitCallback);
@@ -1758,7 +1757,7 @@ namespace ts {
                         exportedNames = append(exportedNames, getDeclarationName(valueDeclaration));
                     }
 
-                    exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings.get(getOriginalNodeId(valueDeclaration)));
+                    exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)]);
                 }
             }
 
@@ -1771,8 +1770,8 @@ namespace ts {
          * @param node The node which should not be substituted.
          */
         function preventSubstitution<T extends Node>(node: T): T {
-            if (noSubstitution === undefined) noSubstitution = createMap<boolean>();
-            noSubstitution.set(getNodeId(node), true);
+            if (noSubstitution === undefined) noSubstitution = sparseArray<boolean>();
+            noSubstitution[getNodeId(node)] = true;
             return node;
         }
 
@@ -1782,7 +1781,7 @@ namespace ts {
          * @param node The node to test.
          */
         function isSubstitutionPrevented(node: Node) {
-            return noSubstitution && node.id && noSubstitution.get(node.id);
+            return noSubstitution && node.id && noSubstitution[node.id];
         }
     }
 }
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 4b0f981f27c..ef7001f3735 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -1,4 +1,4 @@
-/// <reference path="../factory.ts" />
+/// <reference path="../factory.ts" />
 /// <reference path="../visitor.ts" />
 /// <reference path="./destructuring.ts" />
 
@@ -60,7 +60,7 @@ namespace ts {
          * A map that keeps track of aliases created for classes with decorators to avoid issues
          * with the double-binding behavior of classes.
          */
-        let classAliases: Map<Identifier>;
+        let classAliases: SparseArray<Identifier>;
 
         /**
          * Keeps track of whether  we are within any containing namespaces when performing
@@ -752,7 +752,7 @@ namespace ts {
                 if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
                     // record an alias as the class name is not in scope for statics.
                     enableSubstitutionForClassAliases();
-                    classAliases.set(getOriginalNodeId(node), getSynthesizedClone(temp));
+                    classAliases[getOriginalNodeId(node)] = getSynthesizedClone(temp);
                 }
 
                 // To preserve the behavior of the old emitter, we explicitly indent
@@ -1420,7 +1420,7 @@ namespace ts {
                 return undefined;
             }
 
-            const classAlias = classAliases && classAliases.get(getOriginalNodeId(node));
+            const classAlias = classAliases && classAliases[getOriginalNodeId(node)];
             const localName = getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true);
             const decorate = createDecorateHelper(context, decoratorExpressions, localName);
             const expression = createAssignment(localName, classAlias ? createAssignment(classAlias, decorate) : decorate);
@@ -3085,7 +3085,7 @@ namespace ts {
             if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
                 enableSubstitutionForClassAliases();
                 const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
-                classAliases.set(getOriginalNodeId(node), classAlias);
+                classAliases[getOriginalNodeId(node)] = classAlias;
                 hoistVariableDeclaration(classAlias);
                 return classAlias;
             }
@@ -3117,7 +3117,7 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                classAliases = createMap<Identifier>();
+                classAliases = sparseArray<Identifier>();
             }
         }
 
@@ -3230,7 +3230,7 @@ namespace ts {
                     // constructor references in static property initializers.
                     const declaration = resolver.getReferencedValueDeclaration(node);
                     if (declaration) {
-                        const classAlias = classAliases.get(declaration.id);
+                        const classAlias = classAliases[declaration.id];
                         if (classAlias) {
                             const clone = getSynthesizedClone(classAlias);
                             setSourceMapRange(clone, node);
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index 5de16a20fc2..ba5a0d8faea 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -1,4 +1,4 @@
-/// <reference path="program.ts"/>
+/// <reference path="program.ts"/>
 /// <reference path="commandLineParser.ts"/>
 
 namespace ts {
@@ -67,11 +67,13 @@ namespace ts {
     const gutterSeparator = " ";
     const resetEscapeSequence = "\u001b[0m";
     const ellipsis = "...";
-    const categoryFormatMap = createMapFromPairs<string>(
-        [DiagnosticCategory.Warning, yellowForegroundEscapeSequence],
-        [DiagnosticCategory.Error, redForegroundEscapeSequence],
-        [DiagnosticCategory.Message, blueForegroundEscapeSequence],
-    );
+    function getCategoryFormat(category: DiagnosticCategory): string {
+        switch (category) {
+            case DiagnosticCategory.Warning: return yellowForegroundEscapeSequence;
+            case DiagnosticCategory.Error: return redForegroundEscapeSequence;
+            case DiagnosticCategory.Message: return blueForegroundEscapeSequence;
+        }
+    }
 
     function formatAndReset(text: string, formatStyle: string) {
         return formatStyle + text + resetEscapeSequence;
@@ -139,7 +141,7 @@ namespace ts {
             output += `${ relativeFileName }(${ firstLine + 1 },${ firstLineChar + 1 }): `;
         }
 
-        const categoryColor = categoryFormatMap.get(diagnostic.category);
+        const categoryColor = getCategoryFormat(diagnostic.category);
         const category = DiagnosticCategory[diagnostic.category].toLowerCase();
         output += `${ formatAndReset(category, categoryColor) } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }`;
         output += sys.newLine + sys.newLine;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b98a5a493ba..75ff806d605 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1,4 +1,4 @@
-namespace ts {
+namespace ts {
     /**
      * Type of objects whose values are all of the same type.
      * The `in` and `for-in` operators can *not* be safely used,
@@ -8,15 +8,19 @@ namespace ts {
         [index: string]: T;
     }
 
-    /** It's allowed to get/set into a map with numbers. However, when iterating, you may get strings back due to the shim being an ordinary object (which only allows string keys). */
-    export type MapKey = string | number;
+    /**
+     * Like MapLike, but keys must be numbers.
+     */
+    export interface SparseArray<T> {
+        [key: number]: T;
+    }
 
     /** Minimal ES6 Map interface. Does not include iterators as those are hard to shim performantly. */
     export interface Map<T> {
-        get(key: MapKey): T;
-        has(key: MapKey): boolean;
-        set(key: MapKey, value: T): this;
-        delete(key: MapKey): boolean;
+        get(key: string): T;
+        has(key: string): boolean;
+        set(key: string, value: T): this;
+        delete(key: string): boolean;
         clear(): void;
         /** `key` may *not* be a string if it was set with a number and we are not using the shim. */
         forEach(action: (value: T, key: string) => void): void;
@@ -2853,7 +2857,7 @@ namespace ts {
 
     // Enum types (TypeFlags.Enum)
     export interface EnumType extends Type {
-        memberTypes: Map<EnumLiteralType>;
+        memberTypes: SparseArray<EnumLiteralType>;
     }
 
     // Enum types (TypeFlags.EnumLiteral)
@@ -3682,7 +3686,7 @@ namespace ts {
         flags?: EmitFlags;                      // Flags that customize emit
         commentRange?: TextRange;               // The text range to use when emitting leading or trailing comments
         sourceMapRange?: TextRange;             // The text range to use when emitting leading or trailing source mappings
-        tokenSourceMapRanges?: Map<TextRange>;  // The text range to use when emitting source mappings for tokens
+        tokenSourceMapRanges?: SparseArray<TextRange>;  // The text range to use when emitting source mappings for tokens
         constantValue?: number;                 // The constant value of an expression
         externalHelpersModuleName?: Identifier; // The local name for an imported helpers module
         helpers?: EmitHelper[];                 // Emit helpers for the node
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 25973cae5cb..ead1a3b62de 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3311,12 +3311,12 @@ namespace ts {
         return false;
     }
 
-    const syntaxKindCache = createMap<string>();
+    const syntaxKindCache = sparseArray<string>();
 
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
         if (syntaxKindEnum) {
-            const cached = syntaxKindCache.get(kind);
+            const cached = syntaxKindCache[kind];
             if (cached !== undefined) {
                 return cached;
             }
@@ -3324,7 +3324,7 @@ namespace ts {
             for (const name in syntaxKindEnum) {
                 if (syntaxKindEnum[name] === kind) {
                     const result = `${kind} (${name})`;
-                    syntaxKindCache.set(kind, result);
+                    syntaxKindCache[kind] = result;
                     return result;
                 }
             }
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index c9ea2af1a87..2afb1f8301e 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -1,4 +1,4 @@
-/// <reference path="checker.ts" />
+/// <reference path="checker.ts" />
 /// <reference path="factory.ts" />
 /// <reference path="utilities.ts" />
 
@@ -46,54 +46,56 @@ namespace ts {
      *       supplant the existing `forEachChild` implementation if performance is not
      *       significantly impacted.
      */
-    const nodeEdgeTraversalMap = createMapFromPairs<NodeTraversalPath>(
-        [SyntaxKind.QualifiedName, [
-            { name: "left", test: isEntityName },
-            { name: "right", test: isIdentifier }
-        ]],
-        [SyntaxKind.Decorator, [
-            { name: "expression", test: isLeftHandSideExpression }
-        ]],
-        [SyntaxKind.TypeAssertionExpression, [
-            { name: "type", test: isTypeNode },
-            { name: "expression", test: isUnaryExpression }
-        ]],
-        [SyntaxKind.AsExpression, [
-            { name: "expression", test: isExpression },
-            { name: "type", test: isTypeNode }
-        ]],
-        [SyntaxKind.NonNullExpression, [
-            { name: "expression", test: isLeftHandSideExpression }
-        ]],
-        [SyntaxKind.EnumDeclaration, [
-            { name: "decorators", test: isDecorator },
-            { name: "modifiers", test: isModifier },
-            { name: "name", test: isIdentifier },
-            { name: "members", test: isEnumMember }
-        ]],
-        [SyntaxKind.ModuleDeclaration, [
-            { name: "decorators", test: isDecorator },
-            { name: "modifiers", test: isModifier },
-            { name: "name", test: isModuleName },
-            { name: "body", test: isModuleBody }
-        ]],
-        [SyntaxKind.ModuleBlock, [
-            { name: "statements", test: isStatement }
-        ]],
-        [SyntaxKind.ImportEqualsDeclaration, [
-            { name: "decorators", test: isDecorator },
-            { name: "modifiers", test: isModifier },
-            { name: "name", test: isIdentifier },
-            { name: "moduleReference", test: isModuleReference }
-        ]],
-        [SyntaxKind.ExternalModuleReference, [
-            { name: "expression", test: isExpression, optional: true }
-        ]],
-        [SyntaxKind.EnumMember, [
-            { name: "name", test: isPropertyName },
-            { name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
-        ]]
-    );
+    function getNodeEdgeTraversal(kind: SyntaxKind): NodeTraversalPath {
+        switch (kind) {
+            case SyntaxKind.QualifiedName: return [
+                { name: "left", test: isEntityName },
+                { name: "right", test: isIdentifier }
+            ];
+            case SyntaxKind.Decorator: return [
+                { name: "expression", test: isLeftHandSideExpression }
+            ];
+            case SyntaxKind.TypeAssertionExpression: return [
+                { name: "type", test: isTypeNode },
+                { name: "expression", test: isUnaryExpression }
+            ];
+            case SyntaxKind.AsExpression: return [
+                { name: "expression", test: isExpression },
+                { name: "type", test: isTypeNode }
+            ];
+            case SyntaxKind.NonNullExpression: return [
+                { name: "expression", test: isLeftHandSideExpression }
+            ];
+            case SyntaxKind.EnumDeclaration: return [
+                { name: "decorators", test: isDecorator },
+                { name: "modifiers", test: isModifier },
+                { name: "name", test: isIdentifier },
+                { name: "members", test: isEnumMember }
+            ];
+            case SyntaxKind.ModuleDeclaration: return [
+                { name: "decorators", test: isDecorator },
+                { name: "modifiers", test: isModifier },
+                { name: "name", test: isModuleName },
+                { name: "body", test: isModuleBody }
+            ];
+            case SyntaxKind.ModuleBlock: return [
+                { name: "statements", test: isStatement }
+            ];
+            case SyntaxKind.ImportEqualsDeclaration: return [
+                { name: "decorators", test: isDecorator },
+                { name: "modifiers", test: isModifier },
+                { name: "name", test: isIdentifier },
+                { name: "moduleReference", test: isModuleReference }
+            ];
+            case SyntaxKind.ExternalModuleReference: return [
+                { name: "expression", test: isExpression, optional: true }
+            ];
+            case SyntaxKind.EnumMember: return [
+                { name: "name", test: isPropertyName },
+                { name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
+            ];
+        }
+    }
 
     function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
         return node ? f(initial, node) : initial;
@@ -530,7 +532,7 @@ namespace ts {
                 break;
 
             default:
-                const edgeTraversalPath = nodeEdgeTraversalMap.get(kind);
+                const edgeTraversalPath = getNodeEdgeTraversal(kind);
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
                         const value = (<MapLike<any>>node)[edge.name];
@@ -1188,7 +1190,7 @@ namespace ts {
 
             default:
                 let updated: Node & MapLike<any>;
-                const edgeTraversalPath = nodeEdgeTraversalMap.get(kind);
+                const edgeTraversalPath = getNodeEdgeTraversal(kind);
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
                         const value = <Node | NodeArray<Node>>(<Node & MapLike<any>>node)[edge.name];
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index da24fe1606b..70cda27747b 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\harness.ts" />
+/// <reference path="..\harness.ts" />
 
 const expect: typeof _chai.expect = _chai.expect;
 
@@ -416,16 +416,16 @@ namespace ts.server {
         class InProcClient {
             private server: InProcSession;
             private seq = 0;
-            private callbacks = createMap<(resp: protocol.Response) => void>();
+            private callbacks = sparseArray<(resp: protocol.Response) => void>();
             private eventHandlers = createMap<(args: any) => void>();
 
             handle(msg: protocol.Message): void {
                 if (msg.type === "response") {
                     const response = <protocol.Response>msg;
-                    const handler = this.callbacks.get(response.request_seq);
+                    const handler = this.callbacks[response.request_seq];
                     if (handler) {
                         handler(response);
-                        this.callbacks.delete(response.request_seq);
+                        delete this.callbacks[response.request_seq];
                     }
                 }
                 else if (msg.type === "event") {
@@ -460,7 +460,7 @@ namespace ts.server {
                     command,
                     arguments: args
                 });
-                this.callbacks.set(this.seq, callback);
+                this.callbacks[this.seq] = callback;
             }
         };
 
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 5b4ba7d7223..ae213bd0a50 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\harness.ts" />
+/// <reference path="..\harness.ts" />
 /// <reference path="../../server/typingsInstaller/typingsInstaller.ts" />
 
 namespace ts.projectSystem {
@@ -290,30 +290,34 @@ namespace ts.projectSystem {
     }
 
     export class Callbacks {
-        private map = createMap<TimeOutCallback>();
+        private map = sparseArray<TimeOutCallback>();
         private nextId = 1;
 
         register(cb: (...args: any[]) => void, args: any[]) {
             const timeoutId = this.nextId;
             this.nextId++;
-            this.map.set(timeoutId, cb.bind(undefined, ...args));
+            this.map[timeoutId] = cb.bind(undefined, ...args);
             return timeoutId;
         }
         unregister(id: any) {
             if (typeof id === "number") {
-                this.map.delete(id);
+                delete this.map[id];
             }
         }
 
         count() {
-            return this.map.size;
+            let n = 0;
+            for (const _ in this.map) {
+                n++;
+            }
+            return n;
         }
 
         invoke() {
-            this.map.forEach(cb => {
-                cb();
-            });
-            this.map.clear();
+            for (const key in this.map) {
+                this.map[key]();
+            }
+            this.map = sparseArray<TimeOutCallback>();
         }
     }
 
diff --git a/src/services/codefixes/codeFixProvider.ts b/src/services/codefixes/codeFixProvider.ts
index c6373fc1909..fe3e71f1e1c 100644
--- a/src/services/codefixes/codeFixProvider.ts
+++ b/src/services/codefixes/codeFixProvider.ts
@@ -16,25 +16,25 @@ namespace ts {
     }
 
     export namespace codefix {
-        const codeFixes = createMap<CodeFix[]>();
+        const codeFixes = sparseArray<CodeFix[]>();
 
         export function registerCodeFix(action: CodeFix) {
             forEach(action.errorCodes, error => {
-                let fixes = codeFixes.get(error);
+                let fixes = codeFixes[error];
                 if (!fixes) {
                     fixes = [];
-                    codeFixes.set(error, fixes);
+                    codeFixes[error] = fixes;
                 }
                 fixes.push(action);
             });
         }
 
         export function getSupportedErrorCodes() {
-            return keysOfMap(codeFixes);
+            return keysOfSparseArray(codeFixes);
         }
 
         export function getFixes(context: CodeFixContext): CodeAction[] {
-            const fixes = codeFixes.get(context.errorCode);
+            const fixes = codeFixes[context.errorCode];
             let allActions: CodeAction[] = [];
 
             forEach(fixes, f => {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 0e7743e29fc..0df3c3134fe 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -14,16 +14,16 @@ namespace ts.codefix {
     }
 
     class ImportCodeActionMap {
-        private symbolIdToActionMap = createMap<ImportCodeAction[]>();
+        private symbolIdToActionMap = sparseArray<ImportCodeAction[]>();
 
         addAction(symbolId: number, newAction: ImportCodeAction) {
             if (!newAction) {
                 return;
             }
 
-            const actions = this.symbolIdToActionMap.get(symbolId);
+            const actions = this.symbolIdToActionMap[symbolId];
             if (!actions) {
-                this.symbolIdToActionMap.set(symbolId, [newAction]);
+                this.symbolIdToActionMap[symbolId] = [newAction];
                 return;
             }
 
@@ -33,7 +33,7 @@ namespace ts.codefix {
             }
 
             const updatedNewImports: ImportCodeAction[] = [];
-            for (const existingAction of this.symbolIdToActionMap.get(symbolId)) {
+            for (const existingAction of this.symbolIdToActionMap[symbolId]) {
                 if (existingAction.kind === "CodeChange") {
                     // only import actions should compare
                     updatedNewImports.push(existingAction);
@@ -63,7 +63,7 @@ namespace ts.codefix {
             }
             // if we reach here, it means the new one is better or equal to all of the existing ones.
             updatedNewImports.push(newAction);
-            this.symbolIdToActionMap.set(symbolId, updatedNewImports);
+            this.symbolIdToActionMap[symbolId] = updatedNewImports;
         }
 
         addActions(symbolId: number, newActions: ImportCodeAction[]) {
@@ -74,9 +74,9 @@ namespace ts.codefix {
 
         getAllActions() {
             let result: ImportCodeAction[] = [];
-            this.symbolIdToActionMap.forEach(actions => {
-                result = concatenate(result, actions);
-            });
+            for (const key in this.symbolIdToActionMap) {
+                result = concatenate(result, this.symbolIdToActionMap[key])
+            }
             return result;
         }
 
@@ -125,7 +125,7 @@ namespace ts.codefix {
             const symbolIdActionMap = new ImportCodeActionMap();
 
             // this is a module id -> module import declaration map
-            const cachedImportDeclarations = createMap<(ImportDeclaration | ImportEqualsDeclaration)[]>();
+            const cachedImportDeclarations = sparseArray<(ImportDeclaration | ImportEqualsDeclaration)[]>();
             let cachedNewImportInsertPosition: number;
 
             const allPotentialModules = checker.getAmbientModules();
@@ -163,7 +163,7 @@ namespace ts.codefix {
             function getImportDeclarations(moduleSymbol: Symbol) {
                 const moduleSymbolId = getUniqueSymbolId(moduleSymbol);
 
-                const cached = cachedImportDeclarations.get(moduleSymbolId);
+                const cached = cachedImportDeclarations[moduleSymbolId];
                 if (cached) {
                     return cached;
                 }
@@ -175,7 +175,7 @@ namespace ts.codefix {
                         existingDeclarations.push(getImportDeclaration(importModuleSpecifier));
                     }
                 }
-                cachedImportDeclarations.set(moduleSymbolId, existingDeclarations);
+                cachedImportDeclarations[moduleSymbolId] = existingDeclarations;
                 return existingDeclarations;
 
                 function getImportDeclaration(moduleSpecifier: LiteralExpression) {

From 55552585d0f8b060e4794826d833229344fa0b2e Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 27 Dec 2016 12:37:42 -0800
Subject: [PATCH 027/159] Add iterators to Map interface, and shim iterators

---
 src/compiler/checker.ts                    |   2 +-
 src/compiler/core.ts                       | 175 ++++++++++-----------
 src/compiler/transformers/module/system.ts |   2 +-
 src/compiler/types.ts                      |  11 +-
 src/services/codefixes/codeFixProvider.ts  |   2 +-
 src/services/completions.ts                |   2 +-
 6 files changed, 100 insertions(+), 94 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 47a7db16986..4ecfdc4d2f4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6161,7 +6161,7 @@ namespace ts {
             if (!links.resolvedType) {
                 // Deferred resolution of members is handled by resolveObjectTypeMembers
                 const aliasSymbol = getAliasSymbolForTypeNode(node);
-                if (mapIsEmpty(node.symbol.members) && !aliasSymbol) {
+                if (node.symbol.members.size === 0 && !aliasSymbol) {
                     links.resolvedType = emptyTypeLiteralType;
                 }
                 else {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 36847796b6e..a6766887494 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -54,40 +54,48 @@ namespace ts {
         return map;
     }
 
-    /** Methods on native maps but not on shim maps. Only used in this file. */
-    interface ES6Map<T> extends Map<T> {
-        entries(): Iterator<[string, T]>;
-    }
-
-    /** ES6 Iterator type. */
-    interface Iterator<T> {
-        next(): { value: T, done: false } | { value: never, done: true };
-    }
-
-    /** Shim maps support certain methods directly. For native maps we use a function. */
-    interface ShimMap<T> extends Map<T> {
-        isEmpty(): boolean;
-        forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined;
-        some(predicate: (value: T, key: string) => boolean): boolean;
-    }
-
     // The global Map object. This may not be available, so we must test for it.
     declare const Map: { new<T>(): Map<T> } | undefined;
     // Internet Explorer's Map doesn't support iteration, so don't use it.
     // tslint:disable-next-line:no-in-operator
-    const usingNativeMaps = typeof Map !== "undefined" && "entries" in Map.prototype;
-    const MapCtr = usingNativeMaps ? Map : shimMap();
+    const MapCtr = typeof Map !== "undefined" && "entries" in Map.prototype ? Map : shimMap();
 
     // Keep the class inside a function so it doesn't get compiled if it's not used.
     function shimMap(): { new<T>(): Map<T> } {
-        return class<T> implements ShimMap<T> {
+
+        class MapIterator<T, U extends (string | T | [string, T])> {
+            private data: MapLike<T>;
+            private keys: string[];
+            private index = 0;
+            private selector: (data: MapLike<T>, key: string) => U;
+            constructor(data: MapLike<T>, selector: (data: MapLike<T>, key: string) => U) {
+                this.data = data;
+                this.selector = selector;
+                this.keys = Object.keys(data);
+            }
+
+            public next(): { value: U, done: false } | { value: never, done: true } {
+                const index = this.index;
+                if (index < this.keys.length) {
+                    this.index++;
+                    return { value: this.selector(this.data, this.keys[index]), done: false };
+                }
+                return { value: undefined as never, done: true }
+            }
+        }
+
+        return class<T> implements Map<T> {
             private data = createMapLike<T>();
+            public size = 0;
 
             get(key: string): T {
                 return this.data[key];
             }
 
             set(key: string, value: T): this {
+                if (!this.has(key)) {
+                    this.size++;
+                }
                 this.data[key] = value;
                 return this;
             }
@@ -98,15 +106,29 @@ namespace ts {
             }
 
             delete(key: string): boolean {
-                const had = this.has(key);
-                if (had) {
+                if (this.has(key)) {
+                    this.size--;
                     delete this.data[key];
+                    return true;
                 }
-                return had;
+                return false;
             }
 
             clear(): void {
                 this.data = createMapLike<T>();
+                this.size = 0;
+            }
+
+            keys() {
+                return new MapIterator(this.data, (_data, key) => key);
+            }
+
+            values() {
+                return new MapIterator(this.data, (data, key) => data[key]);
+            }
+
+            entries() {
+                return new MapIterator(this.data, (data, key) => [key, data[key]]);
             }
 
             forEach(action: (value: T, key: string) => void): void {
@@ -114,36 +136,6 @@ namespace ts {
                     action(this.data[key], key);
                 }
             }
-
-            isEmpty(): boolean {
-                return !this.some(() => true);
-            }
-
-            get size(): number {
-                let size = 0;
-                for (const _ in this.data) {
-                    size++;
-                }
-                return size;
-            }
-
-            forEachInMap<U>(callback: (value: T, key: string) => U | undefined): U | undefined {
-                for (const key in this.data) {
-                    const result = callback(this.data[key], key);
-                    if (result !== undefined) {
-                        return result;
-                    }
-                }
-            }
-
-            some(predicate: (value: T, key: string) => boolean): boolean {
-                for (const key in this.data) {
-                    if (predicate(this.data[key], key)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
         }
     }
 
@@ -877,65 +869,76 @@ namespace ts {
         return keys;
     }
 
+    function arrayFrom<T>(iterator: Iterator<T>): T[] {
+        const result: T[] = [];
+        for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
+            result.push(value);
+        }
+        return result;
+    }
+
     /**
      * Array of every key in a map.
      * May not actually return string[] if numbers were put into the map.
      */
     export function keysOfMap(map: Map<{}>): string[] {
-        const keys: string[] = [];
-        forEachKeyInMap(map, key => {
-            keys.push(key);
-        });
-        return keys;
+        return arrayFrom(map.keys());
     }
 
     /** Array of every value in a map. */
     export function valuesOfMap<T>(map: Map<T>): T[] {
-        const values: T[] = [];
-        map.forEach(value => {
-            values.push(value);
-        });
-        return values;
+        return arrayFrom(map.values());
     }
 
     /**
      * Calls `callback` for each entry in the map, returning the first defined result.
      * Use `map.forEach` instead for normal iteration.
      */
-    export const forEachInMap: <T, U>(map: Map<T>, callback: (value: T, key: string) => U | undefined) => U | undefined = usingNativeMaps
-        ? <T, U>(map: ES6Map<T>, callback: (value: T, key: string) => U | undefined) => {
-            const iterator = map.entries();
-            while (true) {
-                const { value: pair, done } = iterator.next();
-                if (done) return undefined;
-                const [key, value] = pair;
-                const result = callback(value, key);
-                if (result !== undefined) return result;
+    export function forEachInMap<T, U>(map: Map<T>, callback: (value: T, key: string) => U | undefined): U | undefined {
+        const iterator = map.entries();
+        for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
+            const [key, value] = pair;
+            const result = callback(value, key);
+            if (result !== undefined) {
+                return result;
             }
         }
-        : <T, U>(map: ShimMap<T>, callback: (value: T, key: string) => U | undefined) => map.forEachInMap(callback);
+        return undefined;
+    }
 
     /** `forEachInMap` for just keys. */
     export function forEachKeyInMap<T>(map: Map<{}>, callback: (key: string) => T | undefined): T | undefined {
-        return forEachInMap(map, (_, key) => callback(key));
+        const iterator = map.keys();
+        for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
+            const result = callback(key);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+        return undefined;
     }
 
     /** Whether `predicate` is true for some entry in the map. */
-    export const someInMap: <T>(map: Map<T>, predicate: (value: T, key: string) => boolean) => boolean = usingNativeMaps
-        ? <T>(map: ES6Map<T>, predicate: (value: T, key: string) => boolean) => {
-            const iterator = map.entries();
-            while (true) {
-                const { value: pair, done } = iterator.next();
-                if (done) return false;
-                const [key, value] = pair;
-                if (predicate(value, key)) return true;
+    export function someInMap<T>(map: Map<T>, predicate: (value: T, key: string) => boolean): boolean {
+        const iterator = map.entries();
+        for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
+            const [key, value] = pair;
+            if (predicate(value, key)) {
+                return true;
             }
         }
-        : <T>(map: ShimMap<T>, predicate: (value: T, key: string) => boolean) => map.some(predicate);
+        return false;
+    }
 
     /** `someInMap` for just keys. */
     export function someKeyInMap(map: Map<{}>, predicate: (key: string) => boolean): boolean {
-        return someInMap(map, (_, key) => predicate(key));
+        const iterator = map.keys();
+        for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
+            if (predicate(key)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     /** Copy entries from `source` to `target`. */
@@ -996,10 +999,6 @@ namespace ts {
         return result;
     }
 
-    export const mapIsEmpty: (map: Map<{}>) => boolean = usingNativeMaps
-        ? (map: ES6Map<{}>) => map.size === 0
-        : (map: ShimMap<{}>) => map.isEmpty();
-
     export function cloneMap<T>(map: Map<T>) {
         const clone = createMap<T>();
         copyMapEntries(map, clone);
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index c20e6b5cf32..28179969ba2 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -306,7 +306,7 @@ namespace ts {
             // this set is used to filter names brought by star expors.
 
             // local names set should only be added if we have anything exported
-            if (!moduleInfo.exportedNames && mapIsEmpty(moduleInfo.exportSpecifiers)) {
+            if (!moduleInfo.exportedNames && moduleInfo.exportSpecifiers.size === 0) {
                 // no exported declarations (export var ...) or export specifiers (export {x})
                 // check if we have any non star export declarations.
                 let hasExportDeclarationWithExportClause = false;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 75ff806d605..a842dbb093d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -15,16 +15,23 @@
         [key: number]: T;
     }
 
-    /** Minimal ES6 Map interface. Does not include iterators as those are hard to shim performantly. */
+    /** ES6 Map interface. */
     export interface Map<T> {
         get(key: string): T;
         has(key: string): boolean;
         set(key: string, value: T): this;
         delete(key: string): boolean;
         clear(): void;
-        /** `key` may *not* be a string if it was set with a number and we are not using the shim. */
         forEach(action: (value: T, key: string) => void): void;
         readonly size: number;
+        keys(): Iterator<string>;
+        values(): Iterator<T>;
+        entries(): Iterator<[string, T]>;
+    }
+
+    /** ES6 Iterator type. */
+    export interface Iterator<T> {
+        next(): { value: T, done: false } | { value: never, done: true };
     }
 
     // branded string type used to store absolute, normalized and canonicalized paths
diff --git a/src/services/codefixes/codeFixProvider.ts b/src/services/codefixes/codeFixProvider.ts
index fe3e71f1e1c..f4cb411b064 100644
--- a/src/services/codefixes/codeFixProvider.ts
+++ b/src/services/codefixes/codeFixProvider.ts
@@ -30,7 +30,7 @@ namespace ts {
         }
 
         export function getSupportedErrorCodes() {
-            return keysOfSparseArray(codeFixes);
+            return Object.keys(codeFixes);
         }
 
         export function getFixes(context: CodeFixContext): CodeAction[] {
diff --git a/src/services/completions.ts b/src/services/completions.ts
index f7efe1fec56..4715222db08 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -1566,7 +1566,7 @@ namespace ts.Completions {
                 existingImportsOrExports.set(name.text, true);
             }
 
-            if (mapIsEmpty(existingImportsOrExports)) {
+            if (existingImportsOrExports.size === 0) {
                 return filter(exportsOfModule, e => e.name !== "default");
             }
 

From 3d7b5e6019b73e062dcd01fb6376a7087cf61a12 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 27 Dec 2016 12:46:28 -0800
Subject: [PATCH 028/159] Make `createMapLike` private and rename to
 `createDictionaryObject`

---
 src/compiler/commandLineParser.ts     |  6 +++---
 src/compiler/core.ts                  | 10 +++++-----
 src/harness/harnessLanguageService.ts |  4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index b3c538afd0a..4708b842763 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -762,7 +762,7 @@ namespace ts {
         }
 
         function serializeCompilerOptions(options: CompilerOptions): MapLike<CompilerOptionsValue> {
-            const result = createMapLike<CompilerOptionsValue>();
+            const result: ts.MapLike<CompilerOptionsValue> = {};
             const optionsNameMap = getOptionNameMap().optionNameMap;
 
             for (const name in options) {
@@ -1302,7 +1302,7 @@ namespace ts {
         //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
         const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
         const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
-        const wildcardDirectories = createMapLike<WatchDirectoryFlags>();
+        const wildcardDirectories: ts.MapLike<WatchDirectoryFlags> = {};
         if (include !== undefined) {
             const recursiveKeys: string[] = [];
             for (const file of include) {
@@ -1325,7 +1325,7 @@ namespace ts {
             }
 
             // Remove any subpaths under an existing recursively watched directory.
-            for (const key in wildcardDirectories) {
+            for (const key in wildcardDirectories) if (hasProperty(wildcardDirectories, key)) {
                 for (const recursiveKey of recursiveKeys) {
                     if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
                         delete wildcardDirectories[key];
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index a6766887494..693f6673234 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -26,8 +26,8 @@ namespace ts {
     // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
     export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
 
-    /** Create a MapLike with good performance. Prefer this over a literal `{}`. */
-    export function createMapLike<T>(): MapLike<T> {
+    /** Create a MapLike with good performance. */
+    function createDictionaryObject<T>(): MapLike<T> {
         const map = Object.create(null); // tslint:disable-line:no-null-keyword
 
         // Using 'delete' on an object causes V8 to put the object in dictionary mode.
@@ -39,7 +39,7 @@ namespace ts {
         return map;
     }
 
-    export const sparseArray: <T>() => SparseArray<T> = createMapLike;
+    export const sparseArray: <T>() => SparseArray<T> = createDictionaryObject;
 
     /** Create a new map. If a template object is provided, the map will copy entries from it. */
     export function createMap<T>(template?: MapLike<T>): Map<T> {
@@ -85,7 +85,7 @@ namespace ts {
         }
 
         return class<T> implements Map<T> {
-            private data = createMapLike<T>();
+            private data = createDictionaryObject<T>();
             public size = 0;
 
             get(key: string): T {
@@ -115,7 +115,7 @@ namespace ts {
             }
 
             clear(): void {
-                this.data = createMapLike<T>();
+                this.data = createDictionaryObject<T>();
                 this.size = 0;
             }
 
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index 2ddc38499d0..cd44fbf7a3a 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -262,7 +262,7 @@ namespace Harness.LanguageService {
                 this.getModuleResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
                     const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
-                    const imports = ts.createMapLike<string>();
+                    const imports: ts.MapLike<string> = {};
                     for (const module of preprocessInfo.importedFiles) {
                         const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
                         if (resolutionInfo.resolvedModule) {
@@ -275,7 +275,7 @@ namespace Harness.LanguageService {
                     const scriptInfo = this.getScriptInfo(fileName);
                     if (scriptInfo) {
                         const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
-                        const resolutions = ts.createMapLike<ts.ResolvedTypeReferenceDirective>();
+                        const resolutions: ts.MapLike<ts.ResolvedTypeReferenceDirective> = {};
                         const settings = this.nativeHost.getCompilationSettings();
                         for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {
                             const resolutionInfo = ts.resolveTypeReferenceDirective(typeReferenceDirective.fileName, fileName, settings, moduleResolutionHost);

From f510897dbd5d1f8d0024c1b14243270dfe7006a3 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 28 Dec 2016 08:58:31 -0800
Subject: [PATCH 029/159] Remove "sparseArray" constructor function and just
 use array literals

---
 src/compiler/checker.ts                        |  2 +-
 src/compiler/core.ts                           |  2 --
 src/compiler/factory.ts                        |  2 +-
 src/compiler/moduleNameResolver.ts             |  6 +++---
 src/compiler/transformers/generators.ts        |  2 +-
 src/compiler/transformers/module/module.ts     |  6 +++---
 src/compiler/transformers/module/system.ts     | 10 +++++-----
 src/compiler/transformers/ts.ts                |  2 +-
 src/compiler/utilities.ts                      |  4 ++--
 src/harness/unittests/session.ts               |  2 +-
 src/harness/unittests/tsserverProjectSystem.ts |  4 ++--
 src/services/codefixes/codeFixProvider.ts      |  2 +-
 src/services/codefixes/importFixes.ts          |  4 ++--
 13 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 165e4c3cca7..3ed4c383ef2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4084,7 +4084,7 @@ namespace ts {
                 enumType.symbol = symbol;
                 if (enumHasLiteralMembers(symbol)) {
                     const memberTypeList: Type[] = [];
-                    const memberTypes = sparseArray<EnumLiteralType>();
+                    const memberTypes: SparseArray<EnumLiteralType> = [];
                     for (const declaration of enumType.symbol.declarations) {
                         if (declaration.kind === SyntaxKind.EnumDeclaration) {
                             computeEnumMemberValues(<EnumDeclaration>declaration);
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index a7864a0646f..e9dbdb8786a 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -39,8 +39,6 @@ namespace ts {
         return map;
     }
 
-    export const sparseArray: <T>() => SparseArray<T> = createDictionaryObject;
-
     /** Create a new map. If a template object is provided, the map will copy entries from it. */
     export function createMap<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = new MapCtr<T>();
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 661a0346f26..38e28fc2de0 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -3299,7 +3299,7 @@ namespace ts {
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver, compilerOptions: CompilerOptions): ExternalModuleInfo {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
         const exportSpecifiers = createMap<ExportSpecifier[]>();
-        const exportedBindings = sparseArray<Identifier[]>();
+        const exportedBindings: SparseArray<Identifier[]> = [];
         const uniqueExports = createMap<boolean>();
         let exportedNames: Identifier[];
         let hasExportDefault = false;
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
index a8b634c0234..1efe9078f5a 100644
--- a/src/compiler/moduleNameResolver.ts
+++ b/src/compiler/moduleNameResolver.ts
@@ -388,7 +388,7 @@ namespace ts {
                     }
                 }
             }
-            
+
             function getCommonPrefix(directory: Path, resolution: string) {
                 if (resolution === undefined) {
                     return undefined;
@@ -418,7 +418,7 @@ namespace ts {
             trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
         }
         const containingDirectory = getDirectoryPath(containingFile);
-        let perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
+        const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
         let result = perFolderCache && perFolderCache.get(moduleName);
 
         if (result) {
@@ -991,7 +991,7 @@ namespace ts {
      * - { value: <some-value> } - found - stop searching
      */
     type SearchResult<T> = { value: T | undefined } | undefined;
-    
+
     /**
      * Wraps value to SearchResult.
      * @returns undefined if value is undefined or { value } otherwise
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 7cf7602efa0..8c9da9c4847 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -2096,7 +2096,7 @@ namespace ts {
 
             if (!renamedCatchVariables) {
                 renamedCatchVariables = createMap<boolean>();
-                renamedCatchVariableDeclarations = sparseArray<Identifier>();
+                renamedCatchVariableDeclarations = [];
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
 
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index e5e27c8360d..192f1f81a8f 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -39,8 +39,8 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.ShorthandPropertyAssignment); // Substitutes shorthand property assignments for imported/exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap = sparseArray<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
-        const deferredExports = sparseArray<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
+        const moduleInfoMap: SparseArray<ExternalModuleInfo> = []; // The ExternalModuleInfo for each file.
+        const deferredExports: SparseArray<Statement[]> = []; // Exports to defer until an EndOfDeclarationMarker is found.
 
         let currentSourceFile: SourceFile; // The current file.
         let currentModuleInfo: ExternalModuleInfo; // The ExternalModuleInfo for the current file.
@@ -1105,7 +1105,7 @@ namespace ts {
             if (node.kind === SyntaxKind.SourceFile) {
                 currentSourceFile = <SourceFile>node;
                 currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
-                noSubstitution = sparseArray<boolean>();
+                noSubstitution = [];
 
                 previousOnEmitNode(emitContext, node, emitCallback);
 
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 5f23ccd0669..d332f3376b1 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -28,10 +28,10 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.PostfixUnaryExpression); // Substitutes updates to exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap = sparseArray<ExternalModuleInfo>(); // The ExternalModuleInfo for each file.
-        const deferredExports = sparseArray<Statement[]>(); // Exports to defer until an EndOfDeclarationMarker is found.
-        const exportFunctionsMap = sparseArray<Identifier>(); // The export function associated with a source file.
-        const noSubstitutionMap = sparseArray<SparseArray<boolean>>(); // Set of nodes for which substitution rules should be ignored for each file.
+        const moduleInfoMap: SparseArray<ExternalModuleInfo> = []; // The ExternalModuleInfo for each file.
+        const deferredExports: SparseArray<Statement[]> = []; // Exports to defer until an EndOfDeclarationMarker is found.
+        const exportFunctionsMap: SparseArray<Identifier> = []; // The export function associated with a source file.
+        const noSubstitutionMap: SparseArray<SparseArray<boolean>> = []; // Set of nodes for which substitution rules should be ignored for each file.
 
         let currentSourceFile: SourceFile; // The current file.
         let moduleInfo: ExternalModuleInfo; // ExternalModuleInfo for the current file.
@@ -1771,7 +1771,7 @@ namespace ts {
          * @param node The node which should not be substituted.
          */
         function preventSubstitution<T extends Node>(node: T): T {
-            if (noSubstitution === undefined) noSubstitution = sparseArray<boolean>();
+            if (noSubstitution === undefined) noSubstitution = [];
             noSubstitution[getNodeId(node)] = true;
             return node;
         }
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 0947c894db8..96b00434660 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -3125,7 +3125,7 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                classAliases = sparseArray<Identifier>();
+                classAliases = [];
             }
         }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 7fdda448ae8..44bb05dd4a8 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1,4 +1,4 @@
-/// <reference path="sys.ts" />
+/// <reference path="sys.ts" />
 
 /* @internal */
 namespace ts {
@@ -3365,7 +3365,7 @@ namespace ts {
         return false;
     }
 
-    const syntaxKindCache = sparseArray<string>();
+    const syntaxKindCache: SparseArray<string> = [];
 
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index 70cda27747b..82f6ede865f 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -416,7 +416,7 @@ namespace ts.server {
         class InProcClient {
             private server: InProcSession;
             private seq = 0;
-            private callbacks = sparseArray<(resp: protocol.Response) => void>();
+            private callbacks: SparseArray<(resp: protocol.Response) => void> = [];
             private eventHandlers = createMap<(args: any) => void>();
 
             handle(msg: protocol.Message): void {
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 98a34d2a3bb..4ae2dc7a389 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -292,7 +292,7 @@ namespace ts.projectSystem {
     }
 
     export class Callbacks {
-        private map = sparseArray<TimeOutCallback>();
+        private map: SparseArray<TimeOutCallback> = [];
         private nextId = 1;
 
         register(cb: (...args: any[]) => void, args: any[]) {
@@ -319,7 +319,7 @@ namespace ts.projectSystem {
             for (const key in this.map) {
                 this.map[key]();
             }
-            this.map = sparseArray<TimeOutCallback>();
+            this.map = [];
         }
     }
 
diff --git a/src/services/codefixes/codeFixProvider.ts b/src/services/codefixes/codeFixProvider.ts
index f4cb411b064..e1e3ef18865 100644
--- a/src/services/codefixes/codeFixProvider.ts
+++ b/src/services/codefixes/codeFixProvider.ts
@@ -16,7 +16,7 @@ namespace ts {
     }
 
     export namespace codefix {
-        const codeFixes = sparseArray<CodeFix[]>();
+        const codeFixes: SparseArray<CodeFix[]> = [];
 
         export function registerCodeFix(action: CodeFix) {
             forEach(action.errorCodes, error => {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 0df3c3134fe..81b299bf708 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -14,7 +14,7 @@ namespace ts.codefix {
     }
 
     class ImportCodeActionMap {
-        private symbolIdToActionMap = sparseArray<ImportCodeAction[]>();
+        private symbolIdToActionMap: SparseArray<ImportCodeAction[]> = [];
 
         addAction(symbolId: number, newAction: ImportCodeAction) {
             if (!newAction) {
@@ -125,7 +125,7 @@ namespace ts.codefix {
             const symbolIdActionMap = new ImportCodeActionMap();
 
             // this is a module id -> module import declaration map
-            const cachedImportDeclarations = sparseArray<(ImportDeclaration | ImportEqualsDeclaration)[]>();
+            const cachedImportDeclarations: SparseArray<(ImportDeclaration | ImportEqualsDeclaration)[]> = [];
             let cachedNewImportInsertPosition: number;
 
             const allPotentialModules = checker.getAmbientModules();

From 39c19a74eae41dc83f44885bfa740d50e7b17c81 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 28 Dec 2016 09:05:52 -0800
Subject: [PATCH 030/159] Inline `keysOfMap` and `valuesOfMap`.

---
 src/compiler/commandLineParser.ts              |  8 ++++----
 src/compiler/core.ts                           | 18 +++---------------
 src/compiler/tsc.ts                            |  2 +-
 src/harness/unittests/tsserverProjectSystem.ts |  2 +-
 src/server/project.ts                          |  6 +++---
 src/services/documentRegistry.ts               |  4 ++--
 6 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index a32a5137bad..7bf50f675aa 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -1,4 +1,4 @@
-/// <reference path="sys.ts"/>
+/// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
 /// <reference path="diagnosticInformationMap.generated.ts"/>
@@ -543,7 +543,7 @@ namespace ts {
 
     /* @internal */
     export function createCompilerDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType): Diagnostic {
-        const namesOfType = keysOfMap(opt.type).map(key => `'${key}'`).join(", ");
+        const namesOfType = arrayFrom(opt.type.keys()).map(key => `'${key}'`).join(", ");
         return createCompilerDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
     }
 
@@ -1255,8 +1255,8 @@ namespace ts {
             }
         }
 
-        const literalFiles = valuesOfMap(literalFileMap);
-        const wildcardFiles = valuesOfMap(wildcardFileMap);
+        const literalFiles = arrayFrom(literalFileMap.values());
+        const wildcardFiles = arrayFrom(wildcardFileMap.values());
         wildcardFiles.sort(host.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
         return {
             fileNames: literalFiles.concat(wildcardFiles),
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index e9dbdb8786a..9f8f1ba3f55 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -156,7 +156,7 @@ namespace ts {
         }
 
         function getKeys() {
-            return keysOfMap(files) as Path[];
+            return arrayFrom(files.keys()) as Path[];
         }
 
         // path should already be well-formed so it does not need to be normalized
@@ -867,7 +867,8 @@ namespace ts {
         return keys;
     }
 
-    function arrayFrom<T>(iterator: Iterator<T>): T[] {
+    /** Shims `Array.from`. */
+    export function arrayFrom<T>(iterator: Iterator<T>): T[] {
         const result: T[] = [];
         for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
             result.push(value);
@@ -875,19 +876,6 @@ namespace ts {
         return result;
     }
 
-    /**
-     * Array of every key in a map.
-     * May not actually return string[] if numbers were put into the map.
-     */
-    export function keysOfMap(map: Map<{}>): string[] {
-        return arrayFrom(map.keys());
-    }
-
-    /** Array of every value in a map. */
-    export function valuesOfMap<T>(map: Map<T>): T[] {
-        return arrayFrom(map.values());
-    }
-
     /**
      * Calls `callback` for each entry in the map, returning the first defined result.
      * Use `map.forEach` instead for normal iteration.
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index ba5a0d8faea..a0e7d5ba323 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -680,7 +680,7 @@ namespace ts {
                 description = getDiagnosticText(option.description);
                 const element = (<CommandLineOptionOfListType>option).element;
                 const typeMap = <Map<number | string>>element.type;
-                optionsDescriptionMap.set(description, keysOfMap(typeMap).map(key => `'${key}'`));
+                optionsDescriptionMap.set(description, arrayFrom(typeMap.keys()).map(key => `'${key}'`));
             }
             else {
                 description = getDiagnosticText(option.description);
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 4ae2dc7a389..caa51cd5566 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -246,7 +246,7 @@ namespace ts.projectSystem {
     export function checkMapKeys(caption: string, map: Map<any>, expectedKeys: string[]) {
         assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map`);
         for (const name of expectedKeys) {
-            assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${keysOfMap(map)}`);
+            assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${arrayFrom(map.keys())}`);
         }
     }
 
diff --git a/src/server/project.ts b/src/server/project.ts
index 505eb2f63fb..054b484392e 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\services\services.ts" />
+/// <reference path="..\services\services.ts" />
 /// <reference path="utilities.ts"/>
 /// <reference path="scriptInfo.ts"/>
 /// <reference path="lsHost.ts"/>
@@ -617,7 +617,7 @@ namespace ts.server {
 
                 const added: string[] = [];
                 const removed: string[] = [];
-                const updated: string[] = keysOfMap(updatedFileNames);
+                const updated: string[] = arrayFrom(updatedFileNames.keys());
 
                 forEachKeyInMap(currentFiles, id => {
                     if (!lastReportedFileNames.has(id)) {
@@ -691,7 +691,7 @@ namespace ts.server {
                 })
             }
 
-            const allFileNames = keysOfMap(referencedFiles) as Path[];
+            const allFileNames = arrayFrom(referencedFiles.keys()) as Path[];
             return filter(allFileNames, file => this.projectService.host.fileExists(file));
         }
 
diff --git a/src/services/documentRegistry.ts b/src/services/documentRegistry.ts
index 4291abf6c1f..80b0133ccfe 100644
--- a/src/services/documentRegistry.ts
+++ b/src/services/documentRegistry.ts
@@ -1,4 +1,4 @@
-namespace ts {
+namespace ts {
     /**
       * The document registry represents a store of SourceFile objects that can be shared between
       * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
@@ -121,7 +121,7 @@ namespace ts {
         }
 
         function reportStats() {
-            const bucketInfoArray = keysOfMap(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
+            const bucketInfoArray = arrayFrom(buckets.keys()).filter(name => name && name.charAt(0) === "_").map(name => {
                 const entries = buckets.get(name);
                 const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
                 entries.forEachValue((key, entry) => {

From 932eaa3f90c7418c6e4ce09cdab7ca30309e19ca Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 28 Dec 2016 09:16:38 -0800
Subject: [PATCH 031/159] Rename and consolidate map iteration helpers

---
 src/compiler/checker.ts                       | 10 ++---
 src/compiler/commandLineParser.ts             |  2 +-
 src/compiler/core.ts                          | 37 ++++---------------
 src/compiler/declarationEmitter.ts            |  2 +-
 src/compiler/program.ts                       |  2 +-
 .../unittests/cachingInServerLSHost.ts        |  4 +-
 .../unittests/reuseProgramStructure.ts        |  6 +--
 src/server/editorServices.ts                  |  2 +-
 src/server/project.ts                         |  4 +-
 src/services/completions.ts                   |  4 +-
 src/services/findAllReferences.ts             |  4 +-
 src/services/navigateTo.ts                    |  4 +-
 src/services/transpile.ts                     |  6 +--
 13 files changed, 32 insertions(+), 55 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 3ed4c383ef2..b8e51c7f390 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1815,7 +1815,7 @@ namespace ts {
                     }
 
                     // Check if symbol is any of the alias
-                    return forEachInMap(symbols, symbolFromSymbolTable => {
+                    return forEachEntry(symbols, symbolFromSymbolTable => {
                         if (symbolFromSymbolTable.flags & SymbolFlags.Alias
                             && symbolFromSymbolTable.name !== "export="
                             && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) {
@@ -7758,7 +7758,7 @@ namespace ts {
                     const maybeCache = maybeStack[depth];
                     // If result is definitely true, copy assumptions to global cache, else copy to next level up
                     const destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
-                    copyMapEntries(maybeCache, destinationCache);
+                    copyEntries(maybeCache, destinationCache);
                 }
                 else {
                     // A false result goes straight into global cache (when something is false under assumptions it
@@ -18001,7 +18001,7 @@ namespace ts {
                     else {
                         const blockLocals = catchClause.block.locals;
                         if (blockLocals) {
-                            forEachKeyInMap(catchClause.locals, caughtName => {
+                            forEachKey(catchClause.locals, caughtName => {
                                 const blockLocal = blockLocals.get(caughtName);
                                 if (blockLocal && (blockLocal.flags & SymbolFlags.BlockScopedVariable) !== 0) {
                                     grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
@@ -19187,7 +19187,7 @@ namespace ts {
         }
 
         function hasExportedMembers(moduleSymbol: Symbol) {
-            return someInMap(moduleSymbol.exports, (_, id) => id !== "export=");
+            return forEachEntry(moduleSymbol.exports, (_, id) => id !== "export=");
         }
 
         function checkExternalModuleExports(node: SourceFile | ModuleDeclaration) {
@@ -20097,7 +20097,7 @@ namespace ts {
                 // otherwise - check if at least one export is value
                 symbolLinks.exportsSomeValue = hasExportAssignment
                     ? !!(moduleSymbol.flags & SymbolFlags.Value)
-                    : someInMap(getExportsOfModule(moduleSymbol), isValue);
+                    : forEachEntry(getExportsOfModule(moduleSymbol), isValue);
             }
 
             return symbolLinks.exportsSomeValue;
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 7bf50f675aa..3f89d3e3f9d 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -753,7 +753,7 @@ namespace ts {
 
         function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: Map<string | number>): string | undefined {
             // There is a typeMap associated with this command-line option so use it to map value back to its name
-            return forEachInMap(customTypeMap, (mapValue, key) => {
+            return forEachEntry(customTypeMap, (mapValue, key) => {
                 if (mapValue === value) {
                     return key;
                 }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 9f8f1ba3f55..effe24a253e 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -877,15 +877,15 @@ namespace ts {
     }
 
     /**
-     * Calls `callback` for each entry in the map, returning the first defined result.
+     * Calls `callback` for each entry in the map, returning the first truthy result.
      * Use `map.forEach` instead for normal iteration.
      */
-    export function forEachInMap<T, U>(map: Map<T>, callback: (value: T, key: string) => U | undefined): U | undefined {
+    export function forEachEntry<T, U>(map: Map<T>, callback: (value: T, key: string) => U | undefined): U | undefined {
         const iterator = map.entries();
         for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
             const [key, value] = pair;
             const result = callback(value, key);
-            if (result !== undefined) {
+            if (result) {
                 return result;
             }
         }
@@ -893,42 +893,19 @@ namespace ts {
     }
 
     /** `forEachInMap` for just keys. */
-    export function forEachKeyInMap<T>(map: Map<{}>, callback: (key: string) => T | undefined): T | undefined {
+    export function forEachKey<T>(map: Map<{}>, callback: (key: string) => T | undefined): T | undefined {
         const iterator = map.keys();
         for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
             const result = callback(key);
-            if (result !== undefined) {
+            if (result) {
                 return result;
             }
         }
         return undefined;
     }
 
-    /** Whether `predicate` is true for some entry in the map. */
-    export function someInMap<T>(map: Map<T>, predicate: (value: T, key: string) => boolean): boolean {
-        const iterator = map.entries();
-        for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
-            const [key, value] = pair;
-            if (predicate(value, key)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /** `someInMap` for just keys. */
-    export function someKeyInMap(map: Map<{}>, predicate: (key: string) => boolean): boolean {
-        const iterator = map.keys();
-        for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
-            if (predicate(key)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     /** Copy entries from `source` to `target`. */
-    export function copyMapEntries<T>(source: Map<T>, target: Map<T>): void {
+    export function copyEntries<T>(source: Map<T>, target: Map<T>): void {
         source.forEach((value, key) => {
             target.set(key, value);
         });
@@ -987,7 +964,7 @@ namespace ts {
 
     export function cloneMap<T>(map: Map<T>) {
         const clone = createMap<T>();
-        copyMapEntries(map, clone);
+        copyEntries(map, clone);
         return clone;
     }
 
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index e010519d641..a006ab4fced 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -156,7 +156,7 @@ namespace ts {
         });
 
         if (usedTypeDirectiveReferences) {
-            forEachKeyInMap(usedTypeDirectiveReferences, directive => {
+            forEachKey(usedTypeDirectiveReferences, directive => {
                 referencesOutput += `/// <reference types="${directive}" />${newLine}`;
             });
         }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index b6138e92a7b..324a21f229e 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -464,7 +464,7 @@ namespace ts {
                 classifiableNames = createMap<string>();
 
                 for (const sourceFile of files) {
-                    copyMapEntries(sourceFile.classifiableNames, classifiableNames);
+                    copyEntries(sourceFile.classifiableNames, classifiableNames);
                 }
             }
 
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index b6a90f53259..8389186c486 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\harness.ts" />
+/// <reference path="..\harness.ts" />
 
 namespace ts {
     interface File {
@@ -8,7 +8,7 @@ namespace ts {
 
     function createDefaultServerHost(fileMap: Map<File>): server.ServerHost {
         const existingDirectories = createMap<boolean>();
-        forEachKeyInMap(fileMap, name => {
+        forEachKey(fileMap, name => {
             let dir = getDirectoryPath(name);
             let previous: string;
             do {
diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts
index eb4395154e4..8a89b8d27c6 100644
--- a/src/harness/unittests/reuseProgramStructure.ts
+++ b/src/harness/unittests/reuseProgramStructure.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\harness.ts" />
+/// <reference path="..\harness.ts" />
 /// <reference path="..\..\harness\harnessLanguageService.ts" />
 
 namespace ts {
@@ -197,13 +197,13 @@ namespace ts {
     function mapsAreEqual<T>(left: Map<T>, right: Map<T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
         if (left === right) return true;
         if (!left || !right) return false;
-        const someInLeftHasNoMatch = someInMap(left, (leftValue, leftKey) => {
+        const someInLeftHasNoMatch = forEachEntry(left, (leftValue, leftKey) => {
             if (!right.has(leftKey)) return true;
             const rightValue = right.get(leftKey);
             return !(valuesAreEqual ? valuesAreEqual(leftValue, rightValue) : leftValue === rightValue);
         });
         if (someInLeftHasNoMatch) return false;
-        const someInRightHasNoMatch = someKeyInMap(right, rightKey => !left.has(rightKey));
+        const someInRightHasNoMatch = forEachKey(right, rightKey => !left.has(rightKey));
         return !someInRightHasNoMatch;
     }
 
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 239cd385f57..8865d821d29 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -1373,7 +1373,7 @@ namespace ts.server {
             }
 
             // close projects that were missing in the input list
-            forEachKeyInMap(projectsToClose, externalProjectName => {
+            forEachKey(projectsToClose, externalProjectName => {
                 this.closeExternalProject(externalProjectName, /*suppressRefresh*/ true)
             });
 
diff --git a/src/server/project.ts b/src/server/project.ts
index 054b484392e..94a08a485f9 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -619,12 +619,12 @@ namespace ts.server {
                 const removed: string[] = [];
                 const updated: string[] = arrayFrom(updatedFileNames.keys());
 
-                forEachKeyInMap(currentFiles, id => {
+                forEachKey(currentFiles, id => {
                     if (!lastReportedFileNames.has(id)) {
                         added.push(id);
                     }
                 });
-                forEachKeyInMap(lastReportedFileNames, id => {
+                forEachKey(lastReportedFileNames, id => {
                     if (!currentFiles.has(id)) {
                         removed.push(id);
                     }
diff --git a/src/services/completions.ts b/src/services/completions.ts
index 4715222db08..04e3952b88b 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -1,4 +1,4 @@
-/// <reference path='../compiler/utilities.ts' />
+/// <reference path='../compiler/utilities.ts' />
 
 /* @internal */
 namespace ts.Completions {
@@ -378,7 +378,7 @@ namespace ts.Completions {
                         }
                     }
 
-                    forEachKeyInMap(foundFiles, foundFile => {
+                    forEachKey(foundFiles, foundFile => {
                         result.push(createCompletionEntryForModule(foundFile, ScriptElementKind.scriptElement, span));
                     });
                 }
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 9e53537b69b..a7bf76e0656 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -1,4 +1,4 @@
-/* @internal */
+/* @internal */
 namespace ts.FindAllReferences {
     export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] {
         const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
@@ -508,7 +508,7 @@ namespace ts.FindAllReferences {
                     result.push(ctrKeyword);
                 }
 
-                forEachInMap(classSymbol.exports, member => {
+                classSymbol.exports.forEach(member => {
                     const decl = member.valueDeclaration;
                     if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
                         const body = (<MethodDeclaration>decl).body;
diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts
index 40f22941268..aa72da1ba5c 100644
--- a/src/services/navigateTo.ts
+++ b/src/services/navigateTo.ts
@@ -1,4 +1,4 @@
-/* @internal */
+/* @internal */
 namespace ts.NavigateTo {
     type RawNavigateToItem = { name: string; fileName: string; matchKind: PatternMatchKind; isCaseSensitive: boolean; declaration: Declaration };
 
@@ -14,7 +14,7 @@ namespace ts.NavigateTo {
                 continue;
             }
 
-            forEachInMap(sourceFile.getNamedDeclarations(), (declarations, name) => {
+            forEachEntry(sourceFile.getNamedDeclarations(), (declarations, name) => {
                 if (declarations) {
                     // First do a quick check to see if the name of the declaration matches the
                     // last portion of the (possibly) dotted name they're searching for.
diff --git a/src/services/transpile.ts b/src/services/transpile.ts
index d989a528497..b72399384b7 100644
--- a/src/services/transpile.ts
+++ b/src/services/transpile.ts
@@ -1,4 +1,4 @@
-namespace ts {
+namespace ts {
     export interface TranspileOptions {
         compilerOptions?: CompilerOptions;
         fileName?: string;
@@ -126,7 +126,7 @@ namespace ts {
     function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
         // Lazily create this value to fix module loading errors.
         commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
-            typeof o.type === "object" && !forEachInMap(o.type, v => typeof v !== "number"));
+            typeof o.type === "object" && !forEachEntry(o.type, v => typeof v !== "number"));
 
         options = clone(options);
 
@@ -142,7 +142,7 @@ namespace ts {
                 options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
             }
             else {
-                if (!someInMap(opt.type, v => v === value)) {
+                if (!forEachEntry(opt.type, v => v === value)) {
                     // Supplied value isn't a valid enum value.
                     diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
                 }

From 145f0b2f18b2cc4ad69ed577920a541faf1ad123 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 28 Dec 2016 09:33:43 -0800
Subject: [PATCH 032/159] Add `createMultiMap` to replace `multiMapAdd` and
 `multiMapRemove`

---
 src/compiler/core.ts                          | 52 +++++++++----------
 src/compiler/factory.ts                       | 16 +++++-
 src/compiler/sys.ts                           |  8 +--
 src/harness/fourslash.ts                      |  4 +-
 .../unittests/tsserverProjectSystem.ts        | 12 ++---
 src/services/services.ts                      |  4 +-
 6 files changed, 54 insertions(+), 42 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index effe24a253e..3669ece5104 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -989,43 +989,43 @@ namespace ts {
         return result;
     }
 
-    /**
-     * Adds the value to an array of values associated with the key, and returns the array.
-     * Creates the array if it does not already exist.
-     */
-    export function multiMapAdd<V>(map: Map<V[]>, key: string, value: V): V[] {
-        let values = map.get(key);
+    export interface MultiMap<T> extends Map<T[]> {
+        /**
+         * Adds the value to an array of values associated with the key, and returns the array.
+         * Creates the array if it does not already exist.
+         */
+        add(key: string, value: T): T[];
+        /**
+         * Removes a value from an array of values associated with the key.
+         * Does not preserve the order of those values.
+         * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
+         */
+        remove(key: string, value: T): void;
+    }
+
+    export function createMultiMap<T>(): MultiMap<T> {
+        const map = createMap<T[]>() as MultiMap<T>;
+        map.add = multiMapAdd;
+        map.remove = multiMapRemove;
+        return map;
+    }
+    function multiMapAdd<T>(this: MultiMap<T>, key: string, value: T) {
+        let values = this.get(key);
         if (values) {
             values.push(value);
         }
         else {
-            map.set(key, values = [value]);
+            this.set(key, values = [value]);
         }
         return values;
-    }
 
-    export function multiMapSparseArrayAdd<V>(map: SparseArray<V[]>, key: number, value: V): V[] {
-        let values = map[key];
-        if (values) {
-            values.push(value);
-        }
-        else {
-            map[key] = values = [value];
-        }
-        return values;
     }
-
-    /**
-     * Removes a value from an array of values associated with the key.
-     * Does not preserve the order of those values.
-     * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
-     */
-    export function multiMapRemove<V>(map: Map<V[]>, key: string, value: V): void {
-        const values = map.get(key);
+    function multiMapRemove<T>(this: MultiMap<T>, key: string, value: T) {
+        const values = this.get(key);
         if (values) {
             unorderedRemoveItem(values, value);
             if (!values.length) {
-                map.delete(key);
+                this.delete(key);
             }
         }
     }
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 38e28fc2de0..06108f2d0b2 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -3298,7 +3298,7 @@ namespace ts {
 
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver, compilerOptions: CompilerOptions): ExternalModuleInfo {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
-        const exportSpecifiers = createMap<ExportSpecifier[]>();
+        const exportSpecifiers = createMultiMap<ExportSpecifier>();
         const exportedBindings: SparseArray<Identifier[]> = [];
         const uniqueExports = createMap<boolean>();
         let exportedNames: Identifier[];
@@ -3352,7 +3352,7 @@ namespace ts {
                         for (const specifier of (<ExportDeclaration>node).exportClause.elements) {
                             if (!uniqueExports.get(specifier.name.text)) {
                                 const name = specifier.propertyName || specifier.name;
-                                multiMapAdd(exportSpecifiers, name.text, specifier);
+                                exportSpecifiers.add(name.text, specifier);
 
                                 const decl = resolver.getReferencedImportDeclaration(name)
                                     || resolver.getReferencedValueDeclaration(name);
@@ -3446,4 +3446,16 @@ namespace ts {
         }
         return exportedNames;
     }
+
+    /** Use a sparse array as a multi-map. */
+    function multiMapSparseArrayAdd<V>(map: SparseArray<V[]>, key: number, value: V): V[] {
+        let values = map[key];
+        if (values) {
+            values.push(value);
+        }
+        else {
+            map[key] = values = [value];
+        }
+        return values;
+    }
 }
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index b10d746e435..3c28efd0de8 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -1,4 +1,4 @@
-/// <reference path="core.ts"/>
+/// <reference path="core.ts"/>
 
 namespace ts {
     export type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
@@ -243,7 +243,7 @@ namespace ts {
             function createWatchedFileSet() {
                 const dirWatchers = createMap<DirectoryWatcher>();
                 // One file can have multiple watchers
-                const fileWatcherCallbacks = createMap<FileWatcherCallback[]>();
+                const fileWatcherCallbacks = createMultiMap<FileWatcherCallback>();
                 return { addFile, removeFile };
 
                 function reduceDirWatcherRefCountForFile(fileName: string) {
@@ -275,7 +275,7 @@ namespace ts {
                 }
 
                 function addFileWatcherCallback(filePath: string, callback: FileWatcherCallback): void {
-                    multiMapAdd(fileWatcherCallbacks, filePath, callback);
+                    fileWatcherCallbacks.add(filePath, callback);
                 }
 
                 function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
@@ -291,7 +291,7 @@ namespace ts {
                 }
 
                 function removeFileWatcherCallback(filePath: string, callback: FileWatcherCallback) {
-                    multiMapRemove(fileWatcherCallbacks, filePath, callback);
+                    fileWatcherCallbacks.remove(filePath, callback);
                 }
 
                 function fileEventHandler(eventName: string, relativeFileName: string, baseDirPath: string) {
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 04fd55b110e..8b127afa081 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -1760,10 +1760,10 @@ namespace FourSlash {
         }
 
         public rangesByText(): ts.Map<Range[]> {
-            const result = ts.createMap<Range[]>();
+            const result = ts.createMultiMap<Range>();
             for (const range of this.getRanges()) {
                 const text = this.rangeText(range);
-                ts.multiMapAdd(result, text, range);
+                result.add(text, range);
             }
             return result;
         }
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index caa51cd5566..c8729d49497 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -334,8 +334,8 @@ namespace ts.projectSystem {
         private timeoutCallbacks = new Callbacks();
         private immediateCallbacks = new Callbacks();
 
-        readonly watchedDirectories = createMap<{ cb: DirectoryWatcherCallback, recursive: boolean }[]>();
-        readonly watchedFiles = createMap<FileWatcherCallback[]>();
+        readonly watchedDirectories = createMultiMap<{ cb: DirectoryWatcherCallback, recursive: boolean }>();
+        readonly watchedFiles = createMultiMap<FileWatcherCallback>();
 
         private filesOrFolders: FileOrFolder[];
 
@@ -421,11 +421,11 @@ namespace ts.projectSystem {
         watchDirectory(directoryName: string, callback: DirectoryWatcherCallback, recursive: boolean): DirectoryWatcher {
             const path = this.toPath(directoryName);
             const cbWithRecursive = { cb: callback, recursive };
-            multiMapAdd(this.watchedDirectories, path, cbWithRecursive);
+            this.watchedDirectories.add(path, cbWithRecursive);
             return {
                 referenceCount: 0,
                 directoryName,
-                close: () => multiMapRemove(this.watchedDirectories, path, cbWithRecursive)
+                close: () => this.watchedDirectories.remove(path, cbWithRecursive)
             };
         }
 
@@ -455,8 +455,8 @@ namespace ts.projectSystem {
 
         watchFile(fileName: string, callback: FileWatcherCallback) {
             const path = this.toPath(fileName);
-            multiMapAdd(this.watchedFiles, path, callback);
-            return { close: () => multiMapRemove(this.watchedFiles, path, callback) };
+            this.watchedFiles.add(path, callback);
+            return { close: () => this.watchedFiles.remove(path, callback) };
         }
 
         // TOOD: record and invoke callbacks to simulate timer events
diff --git a/src/services/services.ts b/src/services/services.ts
index 7cd2dce196d..86fbf22b71a 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -518,7 +518,7 @@ namespace ts {
         }
 
         private computeNamedDeclarations(): Map<Declaration[]> {
-            const result = createMap<Declaration[]>();
+            const result = createMultiMap<Declaration>();
 
             forEachChild(this, visit);
 
@@ -527,7 +527,7 @@ namespace ts {
             function addDeclaration(declaration: Declaration) {
                 const name = getDeclarationName(declaration);
                 if (name) {
-                    multiMapAdd(result, name, declaration);
+                    result.add(name, declaration);
                 }
             }
 

From 2e6f369e8fa15ad75668467d1dbcb2b411d7f75d Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 28 Dec 2016 09:39:58 -0800
Subject: [PATCH 033/159] Replace SparseArray<T> with T[]

---
 src/compiler/checker.ts                        |  2 +-
 src/compiler/factory.ts                        |  8 ++++----
 src/compiler/transformers/generators.ts        |  2 +-
 src/compiler/transformers/module/module.ts     |  6 +++---
 src/compiler/transformers/module/system.ts     | 10 +++++-----
 src/compiler/transformers/ts.ts                |  2 +-
 src/compiler/types.ts                          | 11 ++---------
 src/compiler/utilities.ts                      |  2 +-
 src/harness/unittests/session.ts               |  2 +-
 src/harness/unittests/tsserverProjectSystem.ts |  2 +-
 src/services/codefixes/codeFixProvider.ts      |  2 +-
 src/services/codefixes/importFixes.ts          |  4 ++--
 12 files changed, 23 insertions(+), 30 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index fcc44ba087f..48a0876d881 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4084,7 +4084,7 @@ namespace ts {
                 enumType.symbol = symbol;
                 if (enumHasLiteralMembers(symbol)) {
                     const memberTypeList: Type[] = [];
-                    const memberTypes: SparseArray<EnumLiteralType> = [];
+                    const memberTypes: EnumLiteralType[] = [];
                     for (const declaration of enumType.symbol.declarations) {
                         if (declaration.kind === SyntaxKind.EnumDeclaration) {
                             computeEnumMemberValues(<EnumDeclaration>declaration);
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index a326c0c0475..f63094ae16d 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -2646,7 +2646,7 @@ namespace ts {
         return destEmitNode;
     }
 
-    function mergeTokenSourceMapRanges(sourceRanges: SparseArray<TextRange>, destRanges: SparseArray<TextRange>) {
+    function mergeTokenSourceMapRanges(sourceRanges: TextRange[], destRanges: TextRange[]) {
         if (!destRanges) destRanges = [];
         for (const key in sourceRanges) {
             destRanges[key] = sourceRanges[key];
@@ -3277,7 +3277,7 @@ namespace ts {
         externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[]; // imports of other external modules
         externalHelpersImportDeclaration: ImportDeclaration | undefined; // import of external helpers
         exportSpecifiers: Map<ExportSpecifier[]>; // export specifiers by name
-        exportedBindings: SparseArray<Identifier[]>; // exported names of local declarations
+        exportedBindings: Identifier[][]; // exported names of local declarations
         exportedNames: Identifier[]; // all exported names local to module
         exportEquals: ExportAssignment | undefined; // an export= declaration if one was present
         hasExportStarsToExportValues: boolean; // whether this module contains export*
@@ -3286,7 +3286,7 @@ namespace ts {
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver, compilerOptions: CompilerOptions): ExternalModuleInfo {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
         const exportSpecifiers = createMultiMap<ExportSpecifier>();
-        const exportedBindings: SparseArray<Identifier[]> = [];
+        const exportedBindings: Identifier[][] = [];
         const uniqueExports = createMap<boolean>();
         let exportedNames: Identifier[];
         let hasExportDefault = false;
@@ -3435,7 +3435,7 @@ namespace ts {
     }
 
     /** Use a sparse array as a multi-map. */
-    function multiMapSparseArrayAdd<V>(map: SparseArray<V[]>, key: number, value: V): V[] {
+    function multiMapSparseArrayAdd<V>(map: V[][], key: number, value: V): V[] {
         let values = map[key];
         if (values) {
             values.push(value);
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 8c9da9c4847..7dcfe76a427 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -243,7 +243,7 @@ namespace ts {
 
         let currentSourceFile: SourceFile;
         let renamedCatchVariables: Map<boolean>;
-        let renamedCatchVariableDeclarations: SparseArray<Identifier>;
+        let renamedCatchVariableDeclarations: Identifier[];
 
         let inGeneratorFunctionBody: boolean;
         let inStatementContainingYield: boolean;
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index b42f4bf4bee..0adea4fd540 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -39,12 +39,12 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.ShorthandPropertyAssignment); // Substitutes shorthand property assignments for imported/exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap: SparseArray<ExternalModuleInfo> = []; // The ExternalModuleInfo for each file.
-        const deferredExports: SparseArray<Statement[]> = []; // Exports to defer until an EndOfDeclarationMarker is found.
+        const moduleInfoMap: ExternalModuleInfo[] = []; // The ExternalModuleInfo for each file.
+        const deferredExports: Statement[][] = []; // Exports to defer until an EndOfDeclarationMarker is found.
 
         let currentSourceFile: SourceFile; // The current file.
         let currentModuleInfo: ExternalModuleInfo; // The ExternalModuleInfo for the current file.
-        let noSubstitution: SparseArray<boolean>; // Set of nodes for which substitution rules should be ignored.
+        let noSubstitution: boolean[]; // Set of nodes for which substitution rules should be ignored.
 
         return transformSourceFile;
 
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index d332f3376b1..3f1488b649d 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -28,10 +28,10 @@ namespace ts {
         context.enableSubstitution(SyntaxKind.PostfixUnaryExpression); // Substitutes updates to exported symbols.
         context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.
 
-        const moduleInfoMap: SparseArray<ExternalModuleInfo> = []; // The ExternalModuleInfo for each file.
-        const deferredExports: SparseArray<Statement[]> = []; // Exports to defer until an EndOfDeclarationMarker is found.
-        const exportFunctionsMap: SparseArray<Identifier> = []; // The export function associated with a source file.
-        const noSubstitutionMap: SparseArray<SparseArray<boolean>> = []; // Set of nodes for which substitution rules should be ignored for each file.
+        const moduleInfoMap: ExternalModuleInfo[] = []; // The ExternalModuleInfo for each file.
+        const deferredExports: Statement[][] = []; // Exports to defer until an EndOfDeclarationMarker is found.
+        const exportFunctionsMap: Identifier[] = []; // The export function associated with a source file.
+        const noSubstitutionMap: boolean[][] = []; // Set of nodes for which substitution rules should be ignored for each file.
 
         let currentSourceFile: SourceFile; // The current file.
         let moduleInfo: ExternalModuleInfo; // ExternalModuleInfo for the current file.
@@ -39,7 +39,7 @@ namespace ts {
         let contextObject: Identifier; // The context object for the current file.
         let hoistedStatements: Statement[];
         let enclosingBlockScopedContainer: Node;
-        let noSubstitution: SparseArray<boolean>; // Set of nodes for which substitution rules should be ignored.
+        let noSubstitution: boolean[]; // Set of nodes for which substitution rules should be ignored.
 
         return transformSourceFile;
 
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 96b00434660..e2b8b8fe2ec 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -60,7 +60,7 @@ namespace ts {
          * A map that keeps track of aliases created for classes with decorators to avoid issues
          * with the double-binding behavior of classes.
          */
-        let classAliases: SparseArray<Identifier>;
+        let classAliases: Identifier[];
 
         /**
          * Keeps track of whether  we are within any containing namespaces when performing
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index d734998cd7f..2489434c82d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -8,13 +8,6 @@
         [index: string]: T;
     }
 
-    /**
-     * Like MapLike, but keys must be numbers.
-     */
-    export interface SparseArray<T> {
-        [key: number]: T;
-    }
-
     /** ES6 Map interface. */
     export interface Map<T> {
         get(key: string): T;
@@ -2854,7 +2847,7 @@
 
     // Enum types (TypeFlags.Enum)
     export interface EnumType extends Type {
-        memberTypes: SparseArray<EnumLiteralType>;
+        memberTypes: EnumLiteralType[];
     }
 
     // Enum types (TypeFlags.EnumLiteral)
@@ -3684,7 +3677,7 @@
         flags?: EmitFlags;                      // Flags that customize emit
         commentRange?: TextRange;               // The text range to use when emitting leading or trailing comments
         sourceMapRange?: TextRange;             // The text range to use when emitting leading or trailing source mappings
-        tokenSourceMapRanges?: SparseArray<TextRange>;  // The text range to use when emitting source mappings for tokens
+        tokenSourceMapRanges?: TextRange[];  // The text range to use when emitting source mappings for tokens
         constantValue?: number;                 // The constant value of an expression
         externalHelpersModuleName?: Identifier; // The local name for an imported helpers module
         helpers?: EmitHelper[];                 // Emit helpers for the node
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5e15d97752b..f74c450d61a 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3362,7 +3362,7 @@ namespace ts {
         return false;
     }
 
-    const syntaxKindCache: SparseArray<string> = [];
+    const syntaxKindCache: string[] = [];
 
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index 82f6ede865f..15c43d9e76b 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -416,7 +416,7 @@ namespace ts.server {
         class InProcClient {
             private server: InProcSession;
             private seq = 0;
-            private callbacks: SparseArray<(resp: protocol.Response) => void> = [];
+            private callbacks: Array<(resp: protocol.Response) => void> = [];
             private eventHandlers = createMap<(args: any) => void>();
 
             handle(msg: protocol.Message): void {
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 4d4873465b5..b2e2eca2951 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -292,7 +292,7 @@ namespace ts.projectSystem {
     }
 
     export class Callbacks {
-        private map: SparseArray<TimeOutCallback> = [];
+        private map: TimeOutCallback[] = [];
         private nextId = 1;
 
         register(cb: (...args: any[]) => void, args: any[]) {
diff --git a/src/services/codefixes/codeFixProvider.ts b/src/services/codefixes/codeFixProvider.ts
index e1e3ef18865..10d0b8eef34 100644
--- a/src/services/codefixes/codeFixProvider.ts
+++ b/src/services/codefixes/codeFixProvider.ts
@@ -16,7 +16,7 @@ namespace ts {
     }
 
     export namespace codefix {
-        const codeFixes: SparseArray<CodeFix[]> = [];
+        const codeFixes: CodeFix[][] = [];
 
         export function registerCodeFix(action: CodeFix) {
             forEach(action.errorCodes, error => {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 81b299bf708..8cd0a9664a0 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -14,7 +14,7 @@ namespace ts.codefix {
     }
 
     class ImportCodeActionMap {
-        private symbolIdToActionMap: SparseArray<ImportCodeAction[]> = [];
+        private symbolIdToActionMap: ImportCodeAction[][] = [];
 
         addAction(symbolId: number, newAction: ImportCodeAction) {
             if (!newAction) {
@@ -125,7 +125,7 @@ namespace ts.codefix {
             const symbolIdActionMap = new ImportCodeActionMap();
 
             // this is a module id -> module import declaration map
-            const cachedImportDeclarations: SparseArray<(ImportDeclaration | ImportEqualsDeclaration)[]> = [];
+            const cachedImportDeclarations: (ImportDeclaration | ImportEqualsDeclaration)[][] = [];
             let cachedNewImportInsertPosition: number;
 
             const allPotentialModules = checker.getAmbientModules();

From 544d0a43880b3ee6043aae28f8f09210221f60c4 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Fri, 30 Dec 2016 13:03:20 +0100
Subject: [PATCH 034/159] Incorporate changes proposed by @sandersn

---
 src/compiler/checker.ts              | 52 ++++++++++++++++------------
 src/compiler/diagnosticMessages.json |  8 ++---
 2 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index b3820bc0970..4395e852ebc 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2142,24 +2142,25 @@ namespace ts {
             return type.flags & TypeFlags.StringLiteral ? `"${escapeString((<LiteralType>type).text)}"` : (<LiteralType>type).text;
         }
 
-        function getSymbolDisplayBuilder(): SymbolDisplayBuilder {
 
-            function getNameOfSymbol(symbol: Symbol): string {
-                if (symbol.declarations && symbol.declarations.length) {
-                    const declaration = symbol.declarations[0];
-                    if (declaration.name) {
-                        return declarationNameToString(declaration.name);
-                    }
-                    switch (declaration.kind) {
-                        case SyntaxKind.ClassExpression:
-                            return "(Anonymous class)";
-                        case SyntaxKind.FunctionExpression:
-                        case SyntaxKind.ArrowFunction:
-                            return "(Anonymous function)";
-                    }
+        function getNameOfSymbol(symbol: Symbol): string {
+            if (symbol.declarations && symbol.declarations.length) {
+                const declaration = symbol.declarations[0];
+                if (declaration.name) {
+                    return declarationNameToString(declaration.name);
+                }
+                switch (declaration.kind) {
+                    case SyntaxKind.ClassExpression:
+                        return "(Anonymous class)";
+                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.ArrowFunction:
+                        return "(Anonymous function)";
                 }
-                return symbol.name;
             }
+            return symbol.name;
+        }
+
+        function getSymbolDisplayBuilder(): SymbolDisplayBuilder {
 
             /**
              * Writes only the name of the symbol out to the writer. Uses the original source text
@@ -15647,20 +15648,27 @@ namespace ts {
             }
         }
 
-        // Static members may conflict with non-configurable non-writable built-in Function object properties 
-        // see https://github.com/microsoft/typescript/issues/442.
+        /** 
+         * Static members being set on a constructor function may conflict with built-in Function 
+         * object properties. Esp. in ECMAScript 5 there are non-configurable and non-writable 
+         * built-in properties. This check issues a transpile error when a class has a static 
+         * member with the same name as a non-writable built-in property.
+         * 
+         * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
+         * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
+         * @see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
+         * @see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
+         */
         function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) {
             const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
-            const className = getSymbolOfNode(node).name;
+            const className = getNameOfSymbol(getSymbolOfNode(node));
             for (const member of node.members) {
-                const isStatic = forEach(member.modifiers, (m: Modifier) => m.kind  === SyntaxKind.StaticKeyword);
+                const isStatic = getModifierFlags(member) & ModifierFlags.Static;
                 const isMethod = member.kind === SyntaxKind.MethodDeclaration;
                 const memberNameNode = member.name;
                 if (isStatic && memberNameNode) {
                     const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
                     if (languageVersion <= ScriptTarget.ES5) {  // ES3, ES5
-                        // see also http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
-                        // see also http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
                         if (memberName === "prototype" ||
                             memberName === "name" ||
                             memberName === "length" ||
@@ -15671,8 +15679,6 @@ namespace ts {
                         }
                     }
                     else { // ES6+
-                        // see also http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
-                        // see also http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
                         if (memberName === "prototype") {
                             error(memberNameNode, message, memberName, className);
                         }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 0c9bb74f781..476cced3732 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2011,14 +2011,14 @@
         "category": "Error",
         "code": 2697
     },
-    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
-        "category": "Error",
-        "code": 2699
-    },
     "Spread types may only be created from object types.": {
         "category": "Error",
         "code": 2698
     },
+    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
+        "category": "Error",
+        "code": 2699
+    },
     "Rest types may only be created from object types.": {
         "category": "Error",
         "code": 2700

From 244db70730e90bcfa69b00c8f8b8f6973d641bda Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Tue, 3 Jan 2017 14:06:10 +0100
Subject: [PATCH 035/159] Incorporating changes to
 `checkClassForDuplicateDeclarations` in `checker.ts` as proposed by @sandersn

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 4395e852ebc..d6df79e3bbc 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -15610,7 +15610,7 @@ namespace ts {
                     }
                 }
                 else {
-                    const isStatic = forEach(member.modifiers, m => m.kind === SyntaxKind.StaticKeyword);
+                    const isStatic = getModifierFlags(member) & ModifierFlags.Static;
                     const names = isStatic ? staticNames : instanceNames;
 
                     const memberName = member.name && getPropertyNameForPropertyNameNode(member.name);

From 9221336bf1bd8e1c53ec5f3cef12c829aa4c1328 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 6 Jan 2017 13:13:45 -0800
Subject: [PATCH 036/159] Fix name: `mapEntries` is more accurate

---
 src/compiler/core.ts                            | 2 +-
 src/harness/unittests/configurationExtension.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 3b2197d6efa..b65634565b7 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -506,7 +506,7 @@ namespace ts {
         return result;
     }
 
-    export function mapValues<T, U>(map: Map<T>, f: (key: string, value: T) => [string, U]): Map<U> {
+    export function mapEntries<T, U>(map: Map<T>, f: (key: string, value: T) => [string, U]): Map<U> {
         if (!map) {
             return undefined;
         }
diff --git a/src/harness/unittests/configurationExtension.ts b/src/harness/unittests/configurationExtension.ts
index 03eb825811b..c68d07f5123 100644
--- a/src/harness/unittests/configurationExtension.ts
+++ b/src/harness/unittests/configurationExtension.ts
@@ -89,7 +89,7 @@ namespace ts {
     });
 
     const caseInsensitiveBasePath = "c:/dev/";
-    const caseInsensitiveHost = new Utils.MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, mapValues(testContents, (key, content) => [`c:${key}`, content]));
+    const caseInsensitiveHost = new Utils.MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, mapEntries(testContents, (key, content) => [`c:${key}`, content]));
 
     const caseSensitiveBasePath = "/dev/";
     const caseSensitiveHost = new Utils.MockParseConfigHost(caseSensitiveBasePath, /*useCaseSensitiveFileNames*/ true, testContents);

From e8af1d285beb1f3517fd049fb6373958b1b15c4a Mon Sep 17 00:00:00 2001
From: Herrington Darkholme <nonamesheep1@gmail.com>
Date: Sun, 8 Jan 2017 18:31:56 +0800
Subject: [PATCH 037/159] update declaration file to use intrinsic object type

---
 src/lib/es2015.collection.d.ts       | 4 ++--
 src/lib/es2015.core.d.ts             | 2 +-
 src/lib/es2015.iterable.d.ts         | 6 +++---
 src/lib/es2015.proxy.d.ts            | 4 ++--
 src/lib/es2015.symbol.wellknown.d.ts | 4 ++--
 src/lib/es5.d.ts                     | 4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts
index 6a2c43cd050..f93053e4288 100644
--- a/src/lib/es2015.collection.d.ts
+++ b/src/lib/es2015.collection.d.ts
@@ -22,7 +22,7 @@ interface ReadonlyMap<K, V> {
     readonly size: number;
 }
 
-interface WeakMap<K, V> {
+interface WeakMap<K extends object, V> {
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
@@ -31,7 +31,7 @@ interface WeakMap<K, V> {
 
 interface WeakMapConstructor {
     new (): WeakMap<any, any>;
-    new <K, V>(entries?: [K, V][]): WeakMap<K, V>;
+    new <K extends object, V>(entries?: [K, V][]): WeakMap<K, V>;
     readonly prototype: WeakMap<any, any>;
 }
 declare var WeakMap: WeakMapConstructor;
diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts
index 356512ecf58..eb23ce7901f 100644
--- a/src/lib/es2015.core.d.ts
+++ b/src/lib/es2015.core.d.ts
@@ -325,7 +325,7 @@ interface ObjectConstructor {
       * @param o The object to change its prototype.
       * @param proto The value of the new prototype or null.
       */
-    setPrototypeOf(o: any, proto: any): any;
+    setPrototypeOf(o: any, proto: object | null): any;
 
     /**
       * Gets the own property descriptor of the specified object.
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index de339e2bf2c..c8b5158bcd6 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -99,10 +99,10 @@ interface MapConstructor {
     new <K, V>(iterable: Iterable<[K, V]>): Map<K, V>;
 }
 
-interface WeakMap<K, V> { }
+interface WeakMap<K extends object, V> { }
 
 interface WeakMapConstructor {
-    new <K, V>(iterable: Iterable<[K, V]>): WeakMap<K, V>;
+    new <K extends object, V>(iterable: Iterable<[K, V]>): WeakMap<K, V>;
 }
 
 interface Set<T> {
@@ -442,4 +442,4 @@ interface Float64ArrayConstructor {
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
-}
\ No newline at end of file
+}
diff --git a/src/lib/es2015.proxy.d.ts b/src/lib/es2015.proxy.d.ts
index 34aedce0128..efccfd47cc5 100644
--- a/src/lib/es2015.proxy.d.ts
+++ b/src/lib/es2015.proxy.d.ts
@@ -1,5 +1,5 @@
 interface ProxyHandler<T> {
-    getPrototypeOf? (target: T): {} | null;
+    getPrototypeOf? (target: T): object | null;
     setPrototypeOf? (target: T, v: any): boolean;
     isExtensible? (target: T): boolean;
     preventExtensions? (target: T): boolean;
@@ -12,7 +12,7 @@ interface ProxyHandler<T> {
     enumerate? (target: T): PropertyKey[];
     ownKeys? (target: T): PropertyKey[];
     apply? (target: T, thisArg: any, argArray?: any): any;
-    construct? (target: T, argArray: any, newTarget?: any): {};
+    construct? (target: T, argArray: any, newTarget?: any): object
 }
 
 interface ProxyConstructor {
diff --git a/src/lib/es2015.symbol.wellknown.d.ts b/src/lib/es2015.symbol.wellknown.d.ts
index 145d8af6b10..7177b78e483 100644
--- a/src/lib/es2015.symbol.wellknown.d.ts
+++ b/src/lib/es2015.symbol.wellknown.d.ts
@@ -110,7 +110,7 @@ interface Map<K, V> {
     readonly [Symbol.toStringTag]: "Map";
 }
 
-interface WeakMap<K, V>{
+interface WeakMap<K extends object, V>{
     readonly [Symbol.toStringTag]: "WeakMap";
 }
 
@@ -324,4 +324,4 @@ interface Float32Array {
   */
 interface Float64Array {
     readonly [Symbol.toStringTag]: "Float64Array";
-}
\ No newline at end of file
+}
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index e5eabe950a2..038d0344fda 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -146,14 +146,14 @@ interface ObjectConstructor {
       * Creates an object that has the specified prototype, and that optionally contains specified properties.
       * @param o Object to use as a prototype. May be null
       */
-    create<T>(o: T): T;
+    create<T extends object>(o: T): T;
 
     /**
       * Creates an object that has the specified prototype, and that optionally contains specified properties.
       * @param o Object to use as a prototype. May be null
       * @param properties JavaScript object that contains one or more property descriptors.
       */
-    create(o: any, properties: PropertyDescriptorMap): any;
+    create(o: object | null, properties: PropertyDescriptorMap): any;
 
     /**
       * Adds a property to an object, or modifies attributes of an existing property.

From c28d98a1468f9a0541dd4ac64bebcd96d18fe289 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 9 Jan 2017 06:36:07 -0800
Subject: [PATCH 038/159] Fix test

---
 ...eFixClassImplementInterfaceComputedPropertyLiterals.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceComputedPropertyLiterals.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceComputedPropertyLiterals.ts
index 465f9a5b4f1..341b4e59814 100644
--- a/tests/cases/fourslash/codeFixClassImplementInterfaceComputedPropertyLiterals.ts
+++ b/tests/cases/fourslash/codeFixClassImplementInterfaceComputedPropertyLiterals.ts
@@ -10,12 +10,12 @@
 //// class C implements I {[|  |]}
 
 verify.rangeAfterCodeFix(`
-    [1](): string {
-        throw new Error('Method not implemented.');
-    }
-    [2]: boolean;
     ["foo"](o: any): boolean {
         throw new Error('Method not implemented.');
     }
     ["x"]: boolean;
+    [1](): string {
+        throw new Error('Method not implemented.');
+    }
+    [2]: boolean;
 `);
\ No newline at end of file

From 54d64ceb98425d13ae038e91e46849c5c93ab151 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 9 Jan 2017 06:55:42 -0800
Subject: [PATCH 039/159] Respond to PR comment

---
 src/compiler/core.ts | 83 ++++++++++++++++++--------------------------
 1 file changed, 34 insertions(+), 49 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 3aab91f53ad..89131e16359 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -164,6 +164,16 @@ namespace ts {
         return undefined;
     }
 
+    /** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
+    export function findIndex<T>(array: T[], predicate: (element: T, index: number) => boolean): number {
+        for (let i = 0; i < array.length; i++) {
+            if (predicate(array[i], i)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
     /**
      * Returns the first truthy result of `callback`, or else fails.
      * This is like `forEach`, but never returns undefined.
@@ -1810,68 +1820,43 @@ namespace ts {
         // If there are no "includes", then just put everything in results[0].
         const results: string[][] = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
 
+        const comparer = useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive;
         for (const basePath of patterns.basePaths) {
-            forEachFileInRecursiveDirectories(basePath, combinePaths(currentDirectory, basePath), { useCaseSensitiveFileNames, getFileSystemEntries, includeDirectory, visitFile });
+            visitDirectory(basePath, combinePaths(currentDirectory, basePath));
         }
 
         return flatten(results);
 
-        function includeDirectory(absoluteDirectoryName: string): boolean {
-            return (!includeDirectoryRegex || includeDirectoryRegex.test(absoluteDirectoryName)) &&
-                (!excludeRegex || !excludeRegex.test(absoluteDirectoryName));
-        }
+        function visitDirectory(path: string, absolutePath: string) {
+            let { files, directories } = getFileSystemEntries(path);
+            files = files.slice().sort(comparer);
+            directories = directories.slice().sort(comparer);
 
-        function visitFile(fileName: string, absoluteFileName: string): void {
-            if (extensions && !fileExtensionIsAny(fileName, extensions) ||
-                excludeRegex && excludeRegex.test(absoluteFileName)) {
-                return;
-            }
-
-            if (!includeFileRegexes) {
-                results[0].push(fileName);
-            }
-            else {
-                for (let i = 0; i < includeFileRegexes.length; i++) {
-                    if (includeFileRegexes[i].test(absoluteFileName)) {
-                        results[i].push(fileName);
-                        // Only include a file once.
-                        break;
+            for (const current of files) {
+                const name = combinePaths(path, current);
+                const absoluteName = combinePaths(absolutePath, current);
+                if (extensions && !fileExtensionIsAny(name, extensions)) continue;
+                if (excludeRegex && excludeRegex.test(absoluteName)) continue;
+                if (!includeFileRegexes) {
+                    results[0].push(name);
+                }
+                else {
+                    const includeIndex = findIndex(includeFileRegexes, re => re.test(absoluteName));
+                    if (includeIndex !== -1) {
+                        results[includeIndex].push(name);
                     }
                 }
             }
-        }
-    }
 
-    interface RecursiveDirectoryVisitor {
-        useCaseSensitiveFileNames: boolean;
-        getFileSystemEntries: (path: string) => FileSystemEntries;
-        includeDirectory: (absoluteDirectoryName: string) => boolean;
-        visitFile: (fileName: string, absoluteFileName: string) => void;
-    }
-
-    function forEachFileInRecursiveDirectories(start: string, absoluteStart: string, visitor: RecursiveDirectoryVisitor): void {
-        visitDirectory(start, absoluteStart);
-
-        function visitDirectory(path: string, absolutePath: string) {
-            let { files, directories } = visitor.getFileSystemEntries(path);
-            files = sorted(files);
-            directories = sorted(directories);
-
-            for (const file of files) {
-                visitor.visitFile(combinePaths(path, file), combinePaths(absolutePath, file));
-            }
-
-            for (const dir of directories) {
-                const absoluteName = combinePaths(absolutePath, dir);
-                if (visitor.includeDirectory(absoluteName)) {
-                    visitDirectory(combinePaths(path, dir), absoluteName);
+            for (const current of directories) {
+                const name = combinePaths(path, current);
+                const absoluteName = combinePaths(absolutePath, current);
+                if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
+                    (!excludeRegex || !excludeRegex.test(absoluteName))) {
+                    visitDirectory(name, absoluteName);
                 }
             }
         }
-
-        function sorted(names: string[]): string[] {
-            return names.slice().sort(visitor.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
-        }
     }
 
     /**

From 37e18d974158b73d3eb9c7d07b65b34df836120d Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 11 Jan 2017 09:52:50 -0800
Subject: [PATCH 040/159] Add `createMapFromTemplate` helper

---
 src/compiler/checker.ts                       |  6 ++---
 src/compiler/commandLineParser.ts             | 12 +++++-----
 src/compiler/core.ts                          |  7 +++++-
 src/compiler/scanner.ts                       |  2 +-
 src/compiler/transformers/jsx.ts              |  2 +-
 src/compiler/utilities.ts                     |  2 +-
 src/harness/fourslash.ts                      |  2 +-
 .../unittests/cachingInServerLSHost.ts        |  4 ++--
 .../unittests/configurationExtension.ts       |  2 +-
 src/harness/unittests/moduleResolution.ts     | 22 +++++++++----------
 .../unittests/reuseProgramStructure.ts        | 12 +++++-----
 src/server/editorServices.ts                  |  2 +-
 src/services/jsTyping.ts                      |  2 +-
 src/services/transpile.ts                     |  2 +-
 14 files changed, 42 insertions(+), 37 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 3348db7272a..efa10943793 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -315,7 +315,7 @@ namespace ts {
             NullFacts = TypeofEQObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | TypeofNEHostObject | EQNull | EQUndefinedOrNull | NEUndefined | Falsy,
         }
 
-        const typeofEQFacts = createMap({
+        const typeofEQFacts = createMapFromTemplate({
             "string": TypeFacts.TypeofEQString,
             "number": TypeFacts.TypeofEQNumber,
             "boolean": TypeFacts.TypeofEQBoolean,
@@ -325,7 +325,7 @@ namespace ts {
             "function": TypeFacts.TypeofEQFunction
         });
 
-        const typeofNEFacts = createMap({
+        const typeofNEFacts = createMapFromTemplate({
             "string": TypeFacts.TypeofNEString,
             "number": TypeFacts.TypeofNENumber,
             "boolean": TypeFacts.TypeofNEBoolean,
@@ -335,7 +335,7 @@ namespace ts {
             "function": TypeFacts.TypeofNEFunction
         });
 
-        const typeofTypesByName = createMap<Type>({
+        const typeofTypesByName = createMapFromTemplate<Type>({
             "string": stringType,
             "number": numberType,
             "boolean": booleanType,
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index a8c55a88e3f..b222df53630 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -65,7 +65,7 @@ namespace ts {
         },
         {
             name: "jsx",
-            type: createMap({
+            type: createMapFromTemplate({
                 "preserve": JsxEmit.Preserve,
                 "react": JsxEmit.React
             }),
@@ -100,7 +100,7 @@ namespace ts {
         {
             name: "module",
             shortName: "m",
-            type: createMap({
+            type: createMapFromTemplate({
                 "none": ModuleKind.None,
                 "commonjs": ModuleKind.CommonJS,
                 "amd": ModuleKind.AMD,
@@ -114,7 +114,7 @@ namespace ts {
         },
         {
             name: "newLine",
-            type: createMap({
+            type: createMapFromTemplate({
                 "crlf": NewLineKind.CarriageReturnLineFeed,
                 "lf": NewLineKind.LineFeed
             }),
@@ -263,7 +263,7 @@ namespace ts {
         {
             name: "target",
             shortName: "t",
-            type: createMap({
+            type: createMapFromTemplate({
                 "es3": ScriptTarget.ES3,
                 "es5": ScriptTarget.ES5,
                 "es6": ScriptTarget.ES2015,
@@ -300,7 +300,7 @@ namespace ts {
         },
         {
             name: "moduleResolution",
-            type: createMap({
+            type: createMapFromTemplate({
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic,
             }),
@@ -409,7 +409,7 @@ namespace ts {
             type: "list",
             element: {
                 name: "lib",
-                type: createMap({
+                type: createMapFromTemplate({
                     // JavaScript only
                     "es5": "lib.es5.d.ts",
                     "es6": "lib.es2015.d.ts",
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 34c47bcd2f4..7e9cb460ba8 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -40,7 +40,12 @@ namespace ts {
     }
 
     /** Create a new map. If a template object is provided, the map will copy entries from it. */
-    export function createMap<T>(template?: MapLike<T>): Map<T> {
+    export function createMap<T>(): Map<T> {
+        return new MapCtr<T>();
+    }
+
+    //!!!
+    export function createMapFromTemplate<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = new MapCtr<T>();
 
         // Copies keys/values from template. Note that for..in will not throw if
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 259eaa0f5f3..84f1f624d95 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -56,7 +56,7 @@ namespace ts {
         tryScan<T>(callback: () => T): T;
     }
 
-    const textToToken = createMap({
+    const textToToken = createMapFromTemplate({
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
diff --git a/src/compiler/transformers/jsx.ts b/src/compiler/transformers/jsx.ts
index 4879b3c4fa3..1307a7f8551 100644
--- a/src/compiler/transformers/jsx.ts
+++ b/src/compiler/transformers/jsx.ts
@@ -286,7 +286,7 @@ namespace ts {
         }
     }
 
-    const entities = createMap<number>({
+    const entities = createMapFromTemplate<number>({
         "quot": 0x0022,
         "amp": 0x0026,
         "apos": 0x0027,
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index d3e1f076638..932e75d0345 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2351,7 +2351,7 @@ namespace ts {
     // the map below must be updated. Note that this regexp *does not* include the 'delete' character.
     // There is no reason for this other than that JSON.stringify does not handle it either.
     const escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    const escapedCharsMap = createMap({
+    const escapedCharsMap = createMapFromTemplate({
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index ff4964b284b..a75acec53a5 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -90,7 +90,7 @@ namespace FourSlash {
 
     export import IndentStyle = ts.IndentStyle;
 
-    const entityMap = ts.createMap({
+    const entityMap = ts.createMapFromTemplate({
         "&": "&amp;",
         "\"": "&quot;",
         "'": "&#39;",
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index 8389186c486..caeab18958e 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -86,7 +86,7 @@ namespace ts {
                 content: `foo()`
             };
 
-            const serverHost = createDefaultServerHost(createMap({ [root.name]: root, [imported.name]: imported }));
+            const serverHost = createDefaultServerHost(createMapFromTemplate({ [root.name]: root, [imported.name]: imported }));
             const { project, rootScriptInfo } = createProject(root.name, serverHost);
 
             // ensure that imported file was found
@@ -170,7 +170,7 @@ namespace ts {
                 content: `export var y = 1`
             };
 
-            const fileMap = createMap({ [root.name]: root });
+            const fileMap = createMapFromTemplate({ [root.name]: root });
             const serverHost = createDefaultServerHost(fileMap);
             const originalFileExists = serverHost.fileExists;
 
diff --git a/src/harness/unittests/configurationExtension.ts b/src/harness/unittests/configurationExtension.ts
index c68d07f5123..886ee5d54b5 100644
--- a/src/harness/unittests/configurationExtension.ts
+++ b/src/harness/unittests/configurationExtension.ts
@@ -2,7 +2,7 @@
 /// <reference path="..\virtualFileSystem.ts" />
 
 namespace ts {
-    const testContents = createMap({
+    const testContents = createMapFromTemplate({
         "/dev/tsconfig.json": `{
   "extends": "./configs/base",
   "files": [
diff --git a/src/harness/unittests/moduleResolution.ts b/src/harness/unittests/moduleResolution.ts
index 8e4ace38655..aa30f1e01e2 100644
--- a/src/harness/unittests/moduleResolution.ts
+++ b/src/harness/unittests/moduleResolution.ts
@@ -331,7 +331,7 @@ namespace ts {
         }
 
         it("should find all modules", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c/first/shared.ts": `
 class A {}
 export = A`,
@@ -350,7 +350,7 @@ export = C;
         });
 
         it("should find modules in node_modules", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/parent/node_modules/mod/index.d.ts": "export var x",
                 "/parent/app/myapp.ts": `import {x} from "mod"`
             });
@@ -358,7 +358,7 @@ export = C;
         });
 
         it("should find file referenced via absolute and relative names", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c.ts": `/// <reference path="b.ts"/>`,
                 "/a/b/b.ts": "var x"
             });
@@ -409,7 +409,7 @@ export = C;
         }
 
         it("should succeed when the same file is referenced using absolute and relative names", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c.ts": `/// <reference path="d.ts"/>`,
                 "/a/b/d.ts": "var x"
             });
@@ -417,7 +417,7 @@ export = C;
         });
 
         it("should fail when two files used in program differ only in casing (tripleslash references)", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c.ts": `/// <reference path="D.ts"/>`,
                 "/a/b/d.ts": "var x"
             });
@@ -425,7 +425,7 @@ export = C;
         });
 
         it("should fail when two files used in program differ only in casing (imports)", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c.ts": `import {x} from "D"`,
                 "/a/b/d.ts": "export var x"
             });
@@ -433,7 +433,7 @@ export = C;
         });
 
         it("should fail when two files used in program differ only in casing (imports, relative module names)", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "moduleA.ts": `import {x} from "./ModuleB"`,
                 "moduleB.ts": "export var x"
             });
@@ -441,7 +441,7 @@ export = C;
         });
 
         it("should fail when two files exist on disk that differs only in casing", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/b/c.ts": `import {x} from "D"`,
                 "/a/b/D.ts": "export var x",
                 "/a/b/d.ts": "export var y"
@@ -450,7 +450,7 @@ export = C;
         });
 
         it("should fail when module name in 'require' calls has inconsistent casing", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "moduleA.ts": `import a = require("./ModuleC")`,
                 "moduleB.ts": `import a = require("./moduleC")`,
                 "moduleC.ts": "export var x"
@@ -459,7 +459,7 @@ export = C;
         });
 
         it("should fail when module names in 'require' calls has inconsistent casing and current directory has uppercase chars", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/B/c/moduleA.ts": `import a = require("./ModuleC")`,
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
@@ -471,7 +471,7 @@ import b = require("./moduleB");
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "/a/B/c", /*useCaseSensitiveFileNames*/ false, ["moduleD.ts"], [1149]);
         });
         it("should not fail when module names in 'require' calls has consistent casing and current directory has uppercase chars", () => {
-            const files = createMap({
+            const files = createMapFromTemplate({
                 "/a/B/c/moduleA.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts
index 8a89b8d27c6..d13dd7a26fa 100644
--- a/src/harness/unittests/reuseProgramStructure.ts
+++ b/src/harness/unittests/reuseProgramStructure.ts
@@ -322,7 +322,7 @@ namespace ts {
             const options: CompilerOptions = { target };
 
             const program_1 = newProgram(files, ["a.ts"], options);
-            checkResolvedModulesCache(program_1, "a.ts", createMap({ "b": createResolvedModule("b.ts") }));
+            checkResolvedModulesCache(program_1, "a.ts", createMapFromTemplate({ "b": createResolvedModule("b.ts") }));
             checkResolvedModulesCache(program_1, "b.ts", undefined);
 
             const program_2 = updateProgram(program_1, ["a.ts"], options, files => {
@@ -331,7 +331,7 @@ namespace ts {
             assert.isTrue(program_1.structureIsReused);
 
             // content of resolution cache should not change
-            checkResolvedModulesCache(program_1, "a.ts", createMap({ "b": createResolvedModule("b.ts") }));
+            checkResolvedModulesCache(program_1, "a.ts", createMapFromTemplate({ "b": createResolvedModule("b.ts") }));
             checkResolvedModulesCache(program_1, "b.ts", undefined);
 
             // imports has changed - program is not reused
@@ -348,7 +348,7 @@ namespace ts {
                 files[0].text = files[0].text.updateImportsAndExports(newImports);
             });
             assert.isTrue(!program_3.structureIsReused);
-            checkResolvedModulesCache(program_4, "a.ts", createMap({ "b": createResolvedModule("b.ts"), "c": undefined }));
+            checkResolvedModulesCache(program_4, "a.ts", createMapFromTemplate({ "b": createResolvedModule("b.ts"), "c": undefined }));
         });
 
         it("resolved type directives cache follows type directives", () => {
@@ -359,7 +359,7 @@ namespace ts {
             const options: CompilerOptions = { target, typeRoots: ["/types"] };
 
             const program_1 = newProgram(files, ["/a.ts"], options);
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMapFromTemplate({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
             checkResolvedTypeDirectivesCache(program_1, "/types/typedefs/index.d.ts", undefined);
 
             const program_2 = updateProgram(program_1, ["/a.ts"], options, files => {
@@ -368,7 +368,7 @@ namespace ts {
             assert.isTrue(program_1.structureIsReused);
 
             // content of resolution cache should not change
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMapFromTemplate({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
             checkResolvedTypeDirectivesCache(program_1, "/types/typedefs/index.d.ts", undefined);
 
             // type reference directives has changed - program is not reused
@@ -386,7 +386,7 @@ namespace ts {
                 files[0].text = files[0].text.updateReferences(newReferences);
             });
             assert.isTrue(!program_3.structureIsReused);
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMapFromTemplate({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
         });
 
         it("can reuse ambient module declarations from non-modified files", () => {
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 8153804a7bd..25d58142a06 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -51,7 +51,7 @@ namespace ts.server {
     }
 
     const compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);
-    const indentStyle = createMap({
+    const indentStyle = createMapFromTemplate({
         "none": IndentStyle.None,
         "block": IndentStyle.Block,
         "smart": IndentStyle.Smart
diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts
index e587a14b459..248ceef1bd3 100644
--- a/src/services/jsTyping.ts
+++ b/src/services/jsTyping.ts
@@ -76,7 +76,7 @@ namespace ts.JsTyping {
 
         if (!safeList) {
             const result = readConfigFile(safeListPath, (path: string) => host.readFile(path));
-            safeList = result.config ? createMap<string>(result.config) : EmptySafeList;
+            safeList = result.config ? createMapFromTemplate<string>(result.config) : EmptySafeList;
         }
 
         const filesToWatch: string[] = [];
diff --git a/src/services/transpile.ts b/src/services/transpile.ts
index b72399384b7..0b90e9d030b 100644
--- a/src/services/transpile.ts
+++ b/src/services/transpile.ts
@@ -63,7 +63,7 @@
         }
 
         if (transpileOptions.renamedDependencies) {
-            sourceFile.renamedDependencies = createMap(transpileOptions.renamedDependencies);
+            sourceFile.renamedDependencies = createMapFromTemplate(transpileOptions.renamedDependencies);
         }
 
         const newLine = getNewLineCharacter(options);

From b98e82e5c4f1172309546e51d9b871aa2e0c1dc7 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 12 Jan 2017 12:25:00 -0800
Subject: [PATCH 041/159] Fix one more use of `createMapFromTemplate`

---
 src/server/typingsInstaller/nodeTypingsInstaller.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/server/typingsInstaller/nodeTypingsInstaller.ts b/src/server/typingsInstaller/nodeTypingsInstaller.ts
index 19f794ad57c..ff20e89e2d7 100644
--- a/src/server/typingsInstaller/nodeTypingsInstaller.ts
+++ b/src/server/typingsInstaller/nodeTypingsInstaller.ts
@@ -46,7 +46,7 @@ namespace ts.server.typingsInstaller {
         }
         try {
             const content = <TypesRegistryFile>JSON.parse(host.readFile(typesRegistryFilePath));
-            return createMap<void>(content.entries);
+            return createMapFromTemplate<void>(content.entries);
         }
         catch (e) {
             if (log.isEnabled()) {

From 6b6c34bef14ff50733c479b52cdb4b27c20c981d Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 12 Jan 2017 13:56:45 -0800
Subject: [PATCH 042/159] Fix typo

---
 src/compiler/core.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 02cc2b4a453..654b1bc2912 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -895,7 +895,7 @@ namespace ts {
         return undefined;
     }
 
-    /** `forEachInMap` for just keys. */
+    /** `forEachEntry` for just keys. */
     export function forEachKey<T>(map: Map<{}>, callback: (key: string) => T | undefined): T | undefined {
         const iterator = map.keys();
         for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {

From b40613c4d7436c953351e4192a06d07874374470 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 12 Jan 2017 14:01:04 -0800
Subject: [PATCH 043/159] Stop using "dom" types

---
 Jakefile.js            | 4 ++--
 src/compiler/sys.ts    | 3 +++
 src/tsconfig-base.json | 1 +
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/Jakefile.js b/Jakefile.js
index a786fb16ed3..3ee8476c842 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -456,7 +456,7 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
             options += " --stripInternal";
         }
 
-        options += " --target es5 --noUnusedLocals --noUnusedParameters";
+        options += " --target es5 --lib es5,scripthost --noUnusedLocals --noUnusedParameters";
 
         var cmd = host + " " + compilerPath + " " + options + " ";
         cmd = cmd + sources.join(" ");
@@ -726,7 +726,7 @@ compileFile(
 
         // Appending exports at the end of the server library
         var tsserverLibraryDefinitionFileContents =
-            fs.readFileSync(tsserverLibraryDefinitionFile).toString() + 
+            fs.readFileSync(tsserverLibraryDefinitionFile).toString() +
             "\r\nexport = ts;" +
             "\r\nexport as namespace ts;";
 
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 966f0e0cd03..08dc4b6d81f 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -1,5 +1,8 @@
 /// <reference path="core.ts"/>
 
+declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any;
+declare function clearTimeout(handle: any): void;
+
 namespace ts {
     export type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
     export type DirectoryWatcherCallback = (fileName: string) => void;
diff --git a/src/tsconfig-base.json b/src/tsconfig-base.json
index b4c82dbeeee..7c67f49d1e5 100644
--- a/src/tsconfig-base.json
+++ b/src/tsconfig-base.json
@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "lib": ["es5", "scripthost"],
         "noEmitOnError": true,
         "noImplicitAny": true,
         "noImplicitThis": true,

From d630980f793f381b9c8d43c15ef417d82feca588 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 12 Jan 2017 14:25:24 -0800
Subject: [PATCH 044/159] Add dom declarations used by harness

---
 src/harness/harness.ts | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 4094fc773ea..7bd9f0f316a 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -40,8 +40,22 @@ declare namespace NodeJS {
         ActiveXObject: typeof ActiveXObject;
     }
 }
+
+declare var window: {};
+declare var XMLHttpRequest: {
+    new(): XMLHttpRequest;
+}
+interface XMLHttpRequest  {
+    readonly readyState: number;
+    readonly responseText: string;
+    readonly status: number;
+    open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
+    send(data?: string): void;
+    setRequestHeader(header: string, value: string): void;
+}
 /* tslint:enable:no-var-keyword */
 
+
 namespace Utils {
     // Setup some globals based on the current environment
     export const enum ExecutionEnvironment {

From 0b8de64a1b74728f28e4abb1eebdbac6bc877b0a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 13 Jan 2017 13:16:14 -0800
Subject: [PATCH 045/159] Move code out of closure in
 `getReferencedSymbolsForNode`

---
 src/services/findAllReferences.ts           | 2091 +++++++++----------
 tests/cases/fourslash/findAllRefsForRest.ts |    5 +-
 2 files changed, 1046 insertions(+), 1050 deletions(-)

diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 287c16d5e7e..cf502ad50f9 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -30,20 +30,20 @@ namespace ts.FindAllReferences {
                     const labelDefinition = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>node).text);
                     // if we have a label definition, look within its statement for references, if not, then
                     // the label is undefined and we have no results..
-                    return labelDefinition ? getLabelReferencesInNode(labelDefinition.parent, labelDefinition) : undefined;
+                    return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition, cancellationToken);
                 }
                 else {
                     // it is a label definition and not a target, search within the parent labeledStatement
-                    return getLabelReferencesInNode(node.parent, <Identifier>node);
+                    return getLabelReferencesInNode(node.parent, <Identifier>node, cancellationToken);
                 }
             }
 
             if (isThis(node)) {
-                return getReferencesForThisKeyword(node, sourceFiles);
+                return getReferencesForThisKeyword(node, sourceFiles, typeChecker, cancellationToken);
             }
 
             if (node.kind === SyntaxKind.SuperKeyword) {
-                return getReferencesForSuperKeyword(node);
+                return getReferencesForSuperKeyword(node, typeChecker, cancellationToken);
             }
         }
 
@@ -52,10 +52,9 @@ namespace ts.FindAllReferences {
         const symbol = typeChecker.getSymbolAtLocation(node);
 
         if (!implementations && !symbol && node.kind === SyntaxKind.StringLiteral) {
-            return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles);
+            return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, typeChecker, cancellationToken);
         }
 
-
         // Could not find a symbol e.g. unknown identifier
         if (!symbol) {
             // Can't have references to something that we have no symbol for.
@@ -87,7 +86,7 @@ namespace ts.FindAllReferences {
 
         if (scope) {
             result = [];
-            getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
+            getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
         }
         else {
             const internedName = getInternedName(symbol, node);
@@ -98,1158 +97,1156 @@ namespace ts.FindAllReferences {
 
                 if (nameTable[internedName] !== undefined) {
                     result = result || [];
-                    getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
+                    getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
                 }
             }
         }
 
         return result;
+    }
 
-        function getDefinition(symbol: Symbol): ReferencedSymbolDefinitionInfo {
-            const info = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node);
-            const name = map(info.displayParts, p => p.text).join("");
-            const declarations = symbol.declarations;
-            if (!declarations || declarations.length === 0) {
-                return undefined;
-            }
-
-            return {
-                containerKind: "",
-                containerName: "",
-                name,
-                kind: info.symbolKind,
-                fileName: declarations[0].getSourceFile().fileName,
-                textSpan: createTextSpan(declarations[0].getStart(), 0),
-                displayParts: info.displayParts
-            };
-        }
-
-        function getAliasSymbolForPropertyNameSymbol(symbol: Symbol, location: Node): Symbol | undefined {
-            if (symbol.flags & SymbolFlags.Alias) {
-                // Default import get alias
-                const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause);
-                if (defaultImport) {
-                    return typeChecker.getAliasedSymbol(symbol);
-                }
-
-                const importOrExportSpecifier = <ImportOrExportSpecifier>forEach(symbol.declarations,
-                    declaration => (declaration.kind === SyntaxKind.ImportSpecifier ||
-                        declaration.kind === SyntaxKind.ExportSpecifier) ? declaration : undefined);
-                if (importOrExportSpecifier &&
-                    // export { a }
-                    (!importOrExportSpecifier.propertyName ||
-                        // export {a as class } where a is location
-                        importOrExportSpecifier.propertyName === location)) {
-                    // If Import specifier -> get alias
-                    // else Export specifier -> get local target
-                    return importOrExportSpecifier.kind === SyntaxKind.ImportSpecifier ?
-                        typeChecker.getAliasedSymbol(symbol) :
-                        typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier);
-                }
-            }
+    function getDefinition(symbol: Symbol, node: Node, typeChecker: TypeChecker): ReferencedSymbolDefinitionInfo {
+        const info = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node);
+        const name = map(info.displayParts, p => p.text).join("");
+        const declarations = symbol.declarations;
+        if (!declarations || declarations.length === 0) {
             return undefined;
         }
 
-        function followAliasIfNecessary(symbol: Symbol, location: Node): Symbol {
-            return getAliasSymbolForPropertyNameSymbol(symbol, location) || symbol;
-        }
+        return {
+            containerKind: "",
+            containerName: "",
+            name,
+            kind: info.symbolKind,
+            fileName: declarations[0].getSourceFile().fileName,
+            textSpan: createTextSpan(declarations[0].getStart(), 0),
+            displayParts: info.displayParts
+        };
+    }
 
-        function getPropertySymbolOfDestructuringAssignment(location: Node) {
-            return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) &&
-                typeChecker.getPropertySymbolOfDestructuringAssignment(<Identifier>location);
-        }
+    function getAliasSymbolForPropertyNameSymbol(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol | undefined {
+        if (symbol.flags & SymbolFlags.Alias) {
+            // Default import get alias
+            const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause);
+            if (defaultImport) {
+                return typeChecker.getAliasedSymbol(symbol);
+            }
 
-        function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol) {
+            const importOrExportSpecifier = <ImportOrExportSpecifier>forEach(symbol.declarations,
+                declaration => (declaration.kind === SyntaxKind.ImportSpecifier ||
+                    declaration.kind === SyntaxKind.ExportSpecifier) ? declaration : undefined);
+            if (importOrExportSpecifier &&
+                // export { a }
+                (!importOrExportSpecifier.propertyName ||
+                    // export {a as class } where a is location
+                    importOrExportSpecifier.propertyName === location)) {
+                // If Import specifier -> get alias
+                // else Export specifier -> get local target
+                return importOrExportSpecifier.kind === SyntaxKind.ImportSpecifier ?
+                    typeChecker.getAliasedSymbol(symbol) :
+                    typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier);
+            }
+        }
+        return undefined;
+    }
+
+    function followAliasIfNecessary(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol {
+        return getAliasSymbolForPropertyNameSymbol(symbol, location, typeChecker) || symbol;
+    }
+
+    function getPropertySymbolOfDestructuringAssignment(location: Node, typeChecker: TypeChecker) {
+        return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) &&
+            typeChecker.getPropertySymbolOfDestructuringAssignment(<Identifier>location);
+    }
+
+    function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol) {
+        const bindingElement = <BindingElement>getDeclarationOfKind(symbol, SyntaxKind.BindingElement);
+        return bindingElement &&
+            bindingElement.parent.kind === SyntaxKind.ObjectBindingPattern &&
+            !bindingElement.propertyName;
+    }
+
+    function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol, typeChecker: TypeChecker) {
+        if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
             const bindingElement = <BindingElement>getDeclarationOfKind(symbol, SyntaxKind.BindingElement);
-            return bindingElement &&
-                bindingElement.parent.kind === SyntaxKind.ObjectBindingPattern &&
-                !bindingElement.propertyName;
+            const typeOfPattern = typeChecker.getTypeAtLocation(bindingElement.parent);
+            return typeOfPattern && typeChecker.getPropertyOfType(typeOfPattern, (<Identifier>bindingElement.name).text);
+        }
+        return undefined;
+    }
+
+    function getInternedName(symbol: Symbol, location: Node): string {
+        // If this is an export or import specifier it could have been renamed using the 'as' syntax.
+        // If so we want to search for whatever under the cursor.
+        if (isImportOrExportSpecifierName(location)) {
+            return location.getText();
         }
 
-        function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol) {
-            if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
-                const bindingElement = <BindingElement>getDeclarationOfKind(symbol, SyntaxKind.BindingElement);
-                const typeOfPattern = typeChecker.getTypeAtLocation(bindingElement.parent);
-                return typeOfPattern && typeChecker.getPropertyOfType(typeOfPattern, (<Identifier>bindingElement.name).text);
+        // Try to get the local symbol if we're dealing with an 'export default'
+        // since that symbol has the "true" name.
+        const localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol);
+        symbol = localExportDefaultSymbol || symbol;
+
+        return stripQuotes(symbol.name);
+    }
+
+    /**
+     * Determines the smallest scope in which a symbol may have named references.
+     * Note that not every construct has been accounted for. This function can
+     * probably be improved.
+     *
+     * @returns undefined if the scope cannot be determined, implying that
+     * a reference to a symbol can occur anywhere.
+     */
+    function getSymbolScope(symbol: Symbol): Node {
+        // If this is the symbol of a named function expression or named class expression,
+        // then named references are limited to its own scope.
+        const valueDeclaration = symbol.valueDeclaration;
+        if (valueDeclaration && (valueDeclaration.kind === SyntaxKind.FunctionExpression || valueDeclaration.kind === SyntaxKind.ClassExpression)) {
+            return valueDeclaration;
+        }
+
+        // If this is private property or method, the scope is the containing class
+        if (symbol.flags & (SymbolFlags.Property | SymbolFlags.Method)) {
+            const privateDeclaration = forEach(symbol.getDeclarations(), d => (getModifierFlags(d) & ModifierFlags.Private) ? d : undefined);
+            if (privateDeclaration) {
+                return getAncestor(privateDeclaration, SyntaxKind.ClassDeclaration);
             }
+        }
+
+        // If the symbol is an import we would like to find it if we are looking for what it imports.
+        // So consider it visible outside its declaration scope.
+        if (symbol.flags & SymbolFlags.Alias) {
             return undefined;
         }
 
-        function getInternedName(symbol: Symbol, location: Node): string {
-            // If this is an export or import specifier it could have been renamed using the 'as' syntax.
-            // If so we want to search for whatever under the cursor.
-            if (isImportOrExportSpecifierName(location)) {
-                return location.getText();
-            }
-
-            // Try to get the local symbol if we're dealing with an 'export default'
-            // since that symbol has the "true" name.
-            const localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol);
-            symbol = localExportDefaultSymbol || symbol;
-
-            return stripQuotes(symbol.name);
+        // If symbol is of object binding pattern element without property name we would want to
+        // look for property too and that could be anywhere
+        if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
+            return undefined;
         }
 
-        /**
-         * Determines the smallest scope in which a symbol may have named references.
-         * Note that not every construct has been accounted for. This function can
-         * probably be improved.
-         *
-         * @returns undefined if the scope cannot be determined, implying that
-         * a reference to a symbol can occur anywhere.
-         */
-        function getSymbolScope(symbol: Symbol): Node {
-            // If this is the symbol of a named function expression or named class expression,
-            // then named references are limited to its own scope.
-            const valueDeclaration = symbol.valueDeclaration;
-            if (valueDeclaration && (valueDeclaration.kind === SyntaxKind.FunctionExpression || valueDeclaration.kind === SyntaxKind.ClassExpression)) {
-                return valueDeclaration;
-            }
-
-            // If this is private property or method, the scope is the containing class
-            if (symbol.flags & (SymbolFlags.Property | SymbolFlags.Method)) {
-                const privateDeclaration = forEach(symbol.getDeclarations(), d => (getModifierFlags(d) & ModifierFlags.Private) ? d : undefined);
-                if (privateDeclaration) {
-                    return getAncestor(privateDeclaration, SyntaxKind.ClassDeclaration);
-                }
-            }
-
-            // If the symbol is an import we would like to find it if we are looking for what it imports.
-            // So consider it visible outside its declaration scope.
-            if (symbol.flags & SymbolFlags.Alias) {
-                return undefined;
-            }
-
-            // If symbol is of object binding pattern element without property name we would want to
-            // look for property too and that could be anywhere
-            if (isObjectBindingPatternElementWithoutPropertyName(symbol)) {
-                return undefined;
-            }
-
-            // if this symbol is visible from its parent container, e.g. exported, then bail out
-            // if symbol correspond to the union property - bail out
-            if (symbol.parent || (symbol.flags & SymbolFlags.SyntheticProperty)) {
-                return undefined;
-            }
-
-            let scope: Node;
-
-            const declarations = symbol.getDeclarations();
-            if (declarations) {
-                for (const declaration of declarations) {
-                    const container = getContainerNode(declaration);
-
-                    if (!container) {
-                        return undefined;
-                    }
-
-                    if (scope && scope !== container) {
-                        // Different declarations have different containers, bail out
-                        return undefined;
-                    }
-
-                    if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
-                        // This is a global variable and not an external module, any declaration defined
-                        // within this scope is visible outside the file
-                        return undefined;
-                    }
-
-                    // The search scope is the container node
-                    scope = container;
-                }
-            }
-
-            return scope;
+        // if this symbol is visible from its parent container, e.g. exported, then bail out
+        // if symbol correspond to the union property - bail out
+        if (symbol.parent || (symbol.flags & SymbolFlags.SyntheticProperty)) {
+            return undefined;
         }
 
-        function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number): number[] {
-            const positions: number[] = [];
+        let scope: Node;
 
-            /// TODO: Cache symbol existence for files to save text search
-            // Also, need to make this work for unicode escapes.
+        const declarations = symbol.getDeclarations();
+        if (declarations) {
+            for (const declaration of declarations) {
+                const container = getContainerNode(declaration);
 
-            // Be resilient in the face of a symbol with no name or zero length name
-            if (!symbolName || !symbolName.length) {
-                return positions;
-            }
-
-            const text = sourceFile.text;
-            const sourceLength = text.length;
-            const symbolNameLength = symbolName.length;
-
-            let position = text.indexOf(symbolName, start);
-            while (position >= 0) {
-                cancellationToken.throwIfCancellationRequested();
-
-                // If we are past the end, stop looking
-                if (position > end) break;
-
-                // We found a match.  Make sure it's not part of a larger word (i.e. the char
-                // before and after it have to be a non-identifier char).
-                const endPosition = position + symbolNameLength;
-
-                if ((position === 0 || !isIdentifierPart(text.charCodeAt(position - 1), ScriptTarget.Latest)) &&
-                    (endPosition === sourceLength || !isIdentifierPart(text.charCodeAt(endPosition), ScriptTarget.Latest))) {
-                    // Found a real match.  Keep searching.
-                    positions.push(position);
+                if (!container) {
+                    return undefined;
                 }
-                position = text.indexOf(symbolName, position + symbolNameLength + 1);
-            }
 
+                if (scope && scope !== container) {
+                    // Different declarations have different containers, bail out
+                    return undefined;
+                }
+
+                if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
+                    // This is a global variable and not an external module, any declaration defined
+                    // within this scope is visible outside the file
+                    return undefined;
+                }
+
+                // The search scope is the container node
+                scope = container;
+            }
+        }
+
+        return scope;
+    }
+
+    function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number, cancellationToken: CancellationToken): number[] {
+        const positions: number[] = [];
+
+        /// TODO: Cache symbol existence for files to save text search
+        // Also, need to make this work for unicode escapes.
+
+        // Be resilient in the face of a symbol with no name or zero length name
+        if (!symbolName || !symbolName.length) {
             return positions;
         }
 
-        function getLabelReferencesInNode(container: Node, targetLabel: Identifier): ReferencedSymbol[] {
-            const references: ReferenceEntry[] = [];
-            const sourceFile = container.getSourceFile();
-            const labelName = targetLabel.text;
-            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd());
+        const text = sourceFile.text;
+        const sourceLength = text.length;
+        const symbolNameLength = symbolName.length;
+
+        let position = text.indexOf(symbolName, start);
+        while (position >= 0) {
+            cancellationToken.throwIfCancellationRequested();
+
+            // If we are past the end, stop looking
+            if (position > end) break;
+
+            // We found a match.  Make sure it's not part of a larger word (i.e. the char
+            // before and after it have to be a non-identifier char).
+            const endPosition = position + symbolNameLength;
+
+            if ((position === 0 || !isIdentifierPart(text.charCodeAt(position - 1), ScriptTarget.Latest)) &&
+                (endPosition === sourceLength || !isIdentifierPart(text.charCodeAt(endPosition), ScriptTarget.Latest))) {
+                // Found a real match.  Keep searching.
+                positions.push(position);
+            }
+            position = text.indexOf(symbolName, position + symbolNameLength + 1);
+        }
+
+        return positions;
+    }
+
+    function getLabelReferencesInNode(container: Node, targetLabel: Identifier, cancellationToken: CancellationToken): ReferencedSymbol[] {
+        const references: ReferenceEntry[] = [];
+        const sourceFile = container.getSourceFile();
+        const labelName = targetLabel.text;
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd(), cancellationToken);
+        forEach(possiblePositions, position => {
+            cancellationToken.throwIfCancellationRequested();
+
+            const node = getTouchingWord(sourceFile, position);
+            if (!node || node.getWidth() !== labelName.length) {
+                return;
+            }
+
+            // Only pick labels that are either the target label, or have a target that is the target label
+            if (node === targetLabel ||
+                (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) {
+                references.push(getReferenceEntryFromNode(node));
+            }
+        });
+
+        const definition: ReferencedSymbolDefinitionInfo = {
+            containerKind: "",
+            containerName: "",
+            fileName: targetLabel.getSourceFile().fileName,
+            kind: ScriptElementKind.label,
+            name: labelName,
+            textSpan: createTextSpanFromNode(targetLabel, sourceFile),
+            displayParts: [displayPart(labelName, SymbolDisplayPartKind.text)]
+        };
+
+        return [{ definition, references }];
+    }
+
+    function isValidReferencePosition(node: Node, searchSymbolName: string): boolean {
+        // Compare the length so we filter out strict superstrings of the symbol we are looking for
+        switch (node && node.kind) {
+            case SyntaxKind.Identifier:
+                return node.getWidth() === searchSymbolName.length;
+
+            case SyntaxKind.StringLiteral:
+                return (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) &&
+                    // For string literals we have two additional chars for the quotes
+                    node.getWidth() === searchSymbolName.length + 2;
+
+            case SyntaxKind.NumericLiteral:
+                return isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && node.getWidth() === searchSymbolName.length;
+
+            default:
+                return false;
+        }
+    }
+
+    /** Search within node "container" for references for a search value, where the search value is defined as a
+         * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning).
+        * searchLocation: a node where the search value
+        */
+    function getReferencesInNode(container: Node,
+        searchSymbol: Symbol,
+        searchText: string,
+        searchLocation: Node,
+        searchMeaning: SemanticMeaning,
+        findInStrings: boolean,
+        findInComments: boolean,
+        result: ReferencedSymbol[],
+        symbolToIndex: number[],
+        implementations: boolean,
+        typeChecker: TypeChecker,
+        cancellationToken: CancellationToken): void {
+
+        const sourceFile = container.getSourceFile();
+
+        const start = findInComments ? container.getFullStart() : container.getStart();
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd(), cancellationToken);
+
+        const parents = getParentSymbolsOfPropertyAccess();
+        const inheritsFromCache: Map<boolean> = createMap<boolean>();
+
+        if (possiblePositions.length) {
+            // Build the set of symbols to search for, initially it has only the current symbol
+            const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation, typeChecker, implementations);
+
             forEach(possiblePositions, position => {
                 cancellationToken.throwIfCancellationRequested();
 
-                const node = getTouchingWord(sourceFile, position);
-                if (!node || node.getWidth() !== labelName.length) {
+                const referenceLocation = getTouchingPropertyName(sourceFile, position);
+                if (!isValidReferencePosition(referenceLocation, searchText)) {
+                    // This wasn't the start of a token.  Check to see if it might be a
+                    // match in a comment or string if that's what the caller is asking
+                    // for.
+                    if (!implementations && ((findInStrings && isInString(sourceFile, position)) ||
+                        (findInComments && isInNonReferenceComment(sourceFile, position)))) {
+
+                        // In the case where we're looking inside comments/strings, we don't have
+                        // an actual definition.  So just use 'undefined' here.  Features like
+                        // 'Rename' won't care (as they ignore the definitions), and features like
+                        // 'FindReferences' will just filter out these results.
+                        result.push({
+                            definition: undefined,
+                            references: [{
+                                fileName: sourceFile.fileName,
+                                textSpan: createTextSpan(position, searchText.length),
+                                isWriteAccess: false,
+                                isDefinition: false
+                            }]
+                        });
+                    }
                     return;
                 }
 
-                // Only pick labels that are either the target label, or have a target that is the target label
-                if (node === targetLabel ||
-                    (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) {
-                    references.push(getReferenceEntryFromNode(node));
+                if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
+                    return;
+                }
+
+                const referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation);
+                if (referenceSymbol) {
+                    const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
+                    const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
+                    const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
+                        /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker);
+
+                    if (relatedSymbol) {
+                        addReferenceToRelatedSymbol(referenceLocation, relatedSymbol);
+                    }
+                    /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
+                        * has two meaning : property name and property value. Therefore when we do findAllReference at the position where
+                        * an identifier is declared, the language service should return the position of the variable declaration as well as
+                        * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
+                        * position of property accessing, the referenceEntry of such position will be handled in the first case.
+                        */
+                    else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) {
+                        addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
+                    }
+                    else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
+                        findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
+                    }
                 }
             });
+        }
+        return;
 
-            const definition: ReferencedSymbolDefinitionInfo = {
-                containerKind: "",
-                containerName: "",
-                fileName: targetLabel.getSourceFile().fileName,
-                kind: ScriptElementKind.label,
-                name: labelName,
-                textSpan: createTextSpanFromNode(targetLabel, sourceFile),
-                displayParts: [displayPart(labelName, SymbolDisplayPartKind.text)]
-            };
-
-            return [{ definition, references }];
+        /* If we are just looking for implementations and this is a property access expression, we need to get the
+            * symbol of the local type of the symbol the property is being accessed on. This is because our search
+            * symbol may have a different parent symbol if the local type's symbol does not declare the property
+            * being accessed (i.e. it is declared in some parent class or interface)
+            */
+        function getParentSymbolsOfPropertyAccess(): Symbol[] | undefined {
+            if (implementations) {
+                const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(searchLocation);
+                if (propertyAccessExpression) {
+                    const localParentType = typeChecker.getTypeAtLocation(propertyAccessExpression.expression);
+                    if (localParentType) {
+                        if (localParentType.symbol && localParentType.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) && localParentType.symbol !== searchSymbol.parent) {
+                            return [localParentType.symbol];
+                        }
+                        else if (localParentType.flags & TypeFlags.UnionOrIntersection) {
+                            return getSymbolsForClassAndInterfaceComponents(<UnionOrIntersectionType>localParentType);
+                        }
+                    }
+                }
+            }
         }
 
-        function isValidReferencePosition(node: Node, searchSymbolName: string): boolean {
-            if (node) {
-                // Compare the length so we filter out strict superstrings of the symbol we are looking for
-                switch (node.kind) {
-                    case SyntaxKind.Identifier:
-                        return node.getWidth() === searchSymbolName.length;
-
-                    case SyntaxKind.StringLiteral:
-                        if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
-                            isNameOfExternalModuleImportOrDeclaration(node)) {
-                            // For string literals we have two additional chars for the quotes
-                            return node.getWidth() === searchSymbolName.length + 2;
-                        }
-                        break;
-
-                    case SyntaxKind.NumericLiteral:
-                        if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
-                            return node.getWidth() === searchSymbolName.length;
-                        }
-                        break;
-                }
-            }
-
-            return false;
+        function getPropertyAccessExpressionFromRightHandSide(node: Node): PropertyAccessExpression {
+            return isRightSideOfPropertyAccess(node) && <PropertyAccessExpression>node.parent;
         }
 
-        /** Search within node "container" for references for a search value, where the search value is defined as a
-          * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning).
-          * searchLocation: a node where the search value
-          */
-        function getReferencesInNode(container: Node,
-            searchSymbol: Symbol,
-            searchText: string,
-            searchLocation: Node,
-            searchMeaning: SemanticMeaning,
-            findInStrings: boolean,
-            findInComments: boolean,
-            result: ReferencedSymbol[],
-            symbolToIndex: number[]): void {
+        /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses.  */
+        function findAdditionalConstructorReferences(referenceSymbol: Symbol, referenceLocation: Node): void {
+            Debug.assert(isClassLike(searchSymbol.valueDeclaration));
 
-            const sourceFile = container.getSourceFile();
-
-            const start = findInComments ? container.getFullStart() : container.getStart();
-            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd());
-
-            const parents = getParentSymbolsOfPropertyAccess();
-            const inheritsFromCache: Map<boolean> = createMap<boolean>();
-
-            if (possiblePositions.length) {
-                // Build the set of symbols to search for, initially it has only the current symbol
-                const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation);
-
-                forEach(possiblePositions, position => {
-                    cancellationToken.throwIfCancellationRequested();
-
-                    const referenceLocation = getTouchingPropertyName(sourceFile, position);
-                    if (!isValidReferencePosition(referenceLocation, searchText)) {
-                        // This wasn't the start of a token.  Check to see if it might be a
-                        // match in a comment or string if that's what the caller is asking
-                        // for.
-                        if (!implementations && ((findInStrings && isInString(sourceFile, position)) ||
-                            (findInComments && isInNonReferenceComment(sourceFile, position)))) {
-
-                            // In the case where we're looking inside comments/strings, we don't have
-                            // an actual definition.  So just use 'undefined' here.  Features like
-                            // 'Rename' won't care (as they ignore the definitions), and features like
-                            // 'FindReferences' will just filter out these results.
-                            result.push({
-                                definition: undefined,
-                                references: [{
-                                    fileName: sourceFile.fileName,
-                                    textSpan: createTextSpan(position, searchText.length),
-                                    isWriteAccess: false,
-                                    isDefinition: false
-                                }]
-                            });
-                        }
-                        return;
-                    }
-
-                    if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
-                        return;
-                    }
-
-                    const referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation);
-                    if (referenceSymbol) {
-                        const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
-                        const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
-                        const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
-                            /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache);
-
-                        if (relatedSymbol) {
-                            addReferenceToRelatedSymbol(referenceLocation, relatedSymbol);
-                        }
-                        /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
-                            * has two meaning : property name and property value. Therefore when we do findAllReference at the position where
-                            * an identifier is declared, the language service should return the position of the variable declaration as well as
-                            * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
-                            * position of property accessing, the referenceEntry of such position will be handled in the first case.
-                            */
-                        else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) {
-                            addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
-                        }
-                        else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
-                            findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
-                        }
-                    }
-                });
+            const referenceClass = referenceLocation.parent;
+            if (referenceSymbol === searchSymbol && isClassLike(referenceClass)) {
+                Debug.assert(referenceClass.name === referenceLocation);
+                // This is the class declaration containing the constructor.
+                addReferences(findOwnConstructorCalls(searchSymbol));
             }
-            return;
-
-            /* If we are just looking for implementations and this is a property access expression, we need to get the
-             * symbol of the local type of the symbol the property is being accessed on. This is because our search
-             * symbol may have a different parent symbol if the local type's symbol does not declare the property
-             * being accessed (i.e. it is declared in some parent class or interface)
-             */
-            function getParentSymbolsOfPropertyAccess(): Symbol[] | undefined {
-                if (implementations) {
-                    const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(searchLocation);
-                    if (propertyAccessExpression) {
-                        const localParentType = typeChecker.getTypeAtLocation(propertyAccessExpression.expression);
-                        if (localParentType) {
-                            if (localParentType.symbol && localParentType.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) && localParentType.symbol !== searchSymbol.parent) {
-                                return [localParentType.symbol];
-                            }
-                            else if (localParentType.flags & TypeFlags.UnionOrIntersection) {
-                                return getSymbolsForClassAndInterfaceComponents(<UnionOrIntersectionType>localParentType);
-                            }
-                        }
-                    }
+            else {
+                // If this class appears in `extends C`, then the extending class' "super" calls are references.
+                const classExtending = tryGetClassByExtendingIdentifier(referenceLocation);
+                if (classExtending && isClassLike(classExtending) && followAliasIfNecessary(referenceSymbol, referenceLocation, typeChecker) === searchSymbol) {
+                    addReferences(superConstructorAccesses(classExtending));
                 }
             }
+        }
 
-            function getPropertyAccessExpressionFromRightHandSide(node: Node): PropertyAccessExpression {
-                return isRightSideOfPropertyAccess(node) && <PropertyAccessExpression>node.parent;
+        function addReferences(references: Node[]): void {
+            if (references.length) {
+                const referencedSymbol = getReferencedSymbol(searchSymbol);
+                addRange(referencedSymbol.references, map(references, getReferenceEntryFromNode));
+            }
+        }
+
+        /** `classSymbol` is the class where the constructor was defined.
+         * Reference the constructor and all calls to `new this()`.
+         */
+        function findOwnConstructorCalls(classSymbol: Symbol): Node[] {
+            const result: Node[] = [];
+
+            for (const decl of classSymbol.members["__constructor"].declarations) {
+                const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)!
+                Debug.assert(decl.kind === SyntaxKind.Constructor && !!ctrKeyword);
+                result.push(ctrKeyword);
             }
 
-            /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses.  */
-            function findAdditionalConstructorReferences(referenceSymbol: Symbol, referenceLocation: Node): void {
-                Debug.assert(isClassLike(searchSymbol.valueDeclaration));
-
-                const referenceClass = referenceLocation.parent;
-                if (referenceSymbol === searchSymbol && isClassLike(referenceClass)) {
-                    Debug.assert(referenceClass.name === referenceLocation);
-                    // This is the class declaration containing the constructor.
-                    addReferences(findOwnConstructorCalls(searchSymbol));
-                }
-                else {
-                    // If this class appears in `extends C`, then the extending class' "super" calls are references.
-                    const classExtending = tryGetClassByExtendingIdentifier(referenceLocation);
-                    if (classExtending && isClassLike(classExtending) && followAliasIfNecessary(referenceSymbol, referenceLocation) === searchSymbol) {
-                        addReferences(superConstructorAccesses(classExtending));
-                    }
-                }
-            }
-
-            function addReferences(references: Node[]): void {
-                if (references.length) {
-                    const referencedSymbol = getReferencedSymbol(searchSymbol);
-                    addRange(referencedSymbol.references, map(references, getReferenceEntryFromNode));
-                }
-            }
-
-            /** `classSymbol` is the class where the constructor was defined.
-             * Reference the constructor and all calls to `new this()`.
-             */
-            function findOwnConstructorCalls(classSymbol: Symbol): Node[] {
-                const result: Node[] = [];
-
-                for (const decl of classSymbol.members["__constructor"].declarations) {
-                    const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)!
-                    Debug.assert(decl.kind === SyntaxKind.Constructor && !!ctrKeyword);
-                    result.push(ctrKeyword);
-                }
-
-                forEachProperty(classSymbol.exports, member => {
-                    const decl = member.valueDeclaration;
-                    if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
-                        const body = (<MethodDeclaration>decl).body;
-                        if (body) {
-                            forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => {
-                                if (isNewExpressionTarget(thisKeyword)) {
-                                    result.push(thisKeyword);
-                                }
-                            });
-                        }
-                    }
-                });
-
-                return result;
-            }
-
-            /** Find references to `super` in the constructor of an extending class.  */
-            function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
-                const symbol = cls.symbol;
-                const ctr = symbol.members["__constructor"];
-                if (!ctr) {
-                    return [];
-                }
-
-                const result: Node[] = [];
-                for (const decl of ctr.declarations) {
-                    Debug.assert(decl.kind === SyntaxKind.Constructor);
-                    const body = (<ConstructorDeclaration>decl).body;
+            forEachProperty(classSymbol.exports, member => {
+                const decl = member.valueDeclaration;
+                if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
+                    const body = (<MethodDeclaration>decl).body;
                     if (body) {
-                        forEachDescendantOfKind(body, SyntaxKind.SuperKeyword, node => {
-                            if (isCallExpressionTarget(node)) {
-                                result.push(node);
+                        forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => {
+                            if (isNewExpressionTarget(thisKeyword)) {
+                                result.push(thisKeyword);
                             }
                         });
                     }
-                };
-                return result;
-            }
-
-            function getReferencedSymbol(symbol: Symbol): ReferencedSymbol {
-                const symbolId = getSymbolId(symbol);
-                let index = symbolToIndex[symbolId];
-                if (index === undefined) {
-                    index = result.length;
-                    symbolToIndex[symbolId] = index;
-
-                    result.push({
-                        definition: getDefinition(symbol),
-                        references: []
-                    });
                 }
+            });
 
-                return result[index];
-            }
-
-            function addReferenceToRelatedSymbol(node: Node, relatedSymbol: Symbol) {
-                const references = getReferencedSymbol(relatedSymbol).references;
-                if (implementations) {
-                    getImplementationReferenceEntryForNode(node, references);
-                }
-                else {
-                    references.push(getReferenceEntryFromNode(node));
-                }
-            }
-        }
-
-        function getImplementationReferenceEntryForNode(refNode: Node, result: ReferenceEntry[]): void {
-            // Check if we found a function/propertyAssignment/method with an implementation or initializer
-            if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
-                result.push(getReferenceEntryFromNode(refNode.parent));
-            }
-            else if (refNode.kind === SyntaxKind.Identifier) {
-                if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
-                    // Go ahead and dereference the shorthand assignment by going to its definition
-                    getReferenceEntriesForShorthandPropertyAssignment(refNode, typeChecker, result);
-                }
-
-                // Check if the node is within an extends or implements clause
-                const containingClass = getContainingClassIfInHeritageClause(refNode);
-                if (containingClass) {
-                    result.push(getReferenceEntryFromNode(containingClass));
-                    return;
-                }
-
-                // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface
-                const containingTypeReference = getContainingTypeReference(refNode);
-                if (containingTypeReference) {
-                    const parent = containingTypeReference.parent;
-                    if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {
-                        maybeAdd(getReferenceEntryFromNode(parent.initializer));
-                    }
-                    else if (isFunctionLike(parent) && parent.type === containingTypeReference && parent.body) {
-                        if (parent.body.kind === SyntaxKind.Block) {
-                            forEachReturnStatement(<Block>parent.body, returnStatement => {
-                                if (returnStatement.expression && isImplementationExpression(returnStatement.expression)) {
-                                    maybeAdd(getReferenceEntryFromNode(returnStatement.expression));
-                                }
-                            });
-                        }
-                        else if (isImplementationExpression(<Expression>parent.body)) {
-                            maybeAdd(getReferenceEntryFromNode(parent.body));
-                        }
-                    }
-                    else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) {
-                        maybeAdd(getReferenceEntryFromNode(parent.expression));
-                    }
-                }
-            }
-
-            // Type nodes can contain multiple references to the same type. For example:
-            //      let x: Foo & (Foo & Bar) = ...
-            // Because we are returning the implementation locations and not the identifier locations,
-            // duplicate entries would be returned here as each of the type references is part of
-            // the same implementation. For that reason, check before we add a new entry
-            function maybeAdd(a: ReferenceEntry) {
-                if (!forEach(result, b => a.fileName === b.fileName && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length)) {
-                    result.push(a);
-                }
-            }
-        }
-
-        function getSymbolsForClassAndInterfaceComponents(type: UnionOrIntersectionType, result: Symbol[] = []): Symbol[] {
-            for (const componentType of type.types) {
-                if (componentType.symbol && componentType.symbol.getFlags() & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                    result.push(componentType.symbol);
-                }
-                if (componentType.getFlags() & TypeFlags.UnionOrIntersection) {
-                    getSymbolsForClassAndInterfaceComponents(<UnionOrIntersectionType>componentType, result);
-                }
-            }
             return result;
         }
 
-        function getContainingTypeReference(node: Node): Node {
-            let topLevelTypeReference: Node = undefined;
-
-            while (node) {
-                if (isTypeNode(node)) {
-                    topLevelTypeReference = node;
-                }
-                node = node.parent;
+        /** Find references to `super` in the constructor of an extending class.  */
+        function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
+            const symbol = cls.symbol;
+            const ctr = symbol.members["__constructor"];
+            if (!ctr) {
+                return [];
             }
 
-            return topLevelTypeReference;
+            const result: Node[] = [];
+            for (const decl of ctr.declarations) {
+                Debug.assert(decl.kind === SyntaxKind.Constructor);
+                const body = (<ConstructorDeclaration>decl).body;
+                if (body) {
+                    forEachDescendantOfKind(body, SyntaxKind.SuperKeyword, node => {
+                        if (isCallExpressionTarget(node)) {
+                            result.push(node);
+                        }
+                    });
+                }
+            };
+            return result;
         }
 
-        function getContainingClassIfInHeritageClause(node: Node): ClassLikeDeclaration {
-            if (node && node.parent) {
-                if (node.kind === SyntaxKind.ExpressionWithTypeArguments
-                    && node.parent.kind === SyntaxKind.HeritageClause
-                    && isClassLike(node.parent.parent)) {
-                    return node.parent.parent;
-                }
+        function getReferencedSymbol(symbol: Symbol): ReferencedSymbol {
+            const symbolId = getSymbolId(symbol);
+            let index = symbolToIndex[symbolId];
+            if (index === undefined) {
+                index = result.length;
+                symbolToIndex[symbolId] = index;
 
-                else if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PropertyAccessExpression) {
-                    return getContainingClassIfInHeritageClause(node.parent);
+                result.push({
+                    definition: getDefinition(symbol, searchLocation, typeChecker),
+                    references: []
+                });
+            }
+
+            return result[index];
+        }
+
+        function addReferenceToRelatedSymbol(node: Node, relatedSymbol: Symbol) {
+            const references = getReferencedSymbol(relatedSymbol).references;
+            if (implementations) {
+                getImplementationReferenceEntryForNode(node, references, typeChecker);
+            }
+            else {
+                references.push(getReferenceEntryFromNode(node));
+            }
+        }
+    }
+
+    function getImplementationReferenceEntryForNode(refNode: Node, result: ReferenceEntry[], typeChecker: TypeChecker): void {
+        // Check if we found a function/propertyAssignment/method with an implementation or initializer
+        if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
+            result.push(getReferenceEntryFromNode(refNode.parent));
+        }
+        else if (refNode.kind === SyntaxKind.Identifier) {
+            if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                // Go ahead and dereference the shorthand assignment by going to its definition
+                getReferenceEntriesForShorthandPropertyAssignment(refNode, typeChecker, result);
+            }
+
+            // Check if the node is within an extends or implements clause
+            const containingClass = getContainingClassIfInHeritageClause(refNode);
+            if (containingClass) {
+                result.push(getReferenceEntryFromNode(containingClass));
+                return;
+            }
+
+            // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface
+            const containingTypeReference = getContainingTypeReference(refNode);
+            if (containingTypeReference) {
+                const parent = containingTypeReference.parent;
+                if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {
+                    maybeAdd(getReferenceEntryFromNode(parent.initializer));
+                }
+                else if (isFunctionLike(parent) && parent.type === containingTypeReference && parent.body) {
+                    if (parent.body.kind === SyntaxKind.Block) {
+                        forEachReturnStatement(<Block>parent.body, returnStatement => {
+                            if (returnStatement.expression && isImplementationExpression(returnStatement.expression)) {
+                                maybeAdd(getReferenceEntryFromNode(returnStatement.expression));
+                            }
+                        });
+                    }
+                    else if (isImplementationExpression(<Expression>parent.body)) {
+                        maybeAdd(getReferenceEntryFromNode(parent.body));
+                    }
+                }
+                else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) {
+                    maybeAdd(getReferenceEntryFromNode(parent.expression));
                 }
             }
-            return undefined;
         }
 
-        /**
-         * Returns true if this is an expression that can be considered an implementation
-         */
-        function isImplementationExpression(node: Expression): boolean {
-            // Unwrap parentheses
-            if (node.kind === SyntaxKind.ParenthesizedExpression) {
+        // Type nodes can contain multiple references to the same type. For example:
+        //      let x: Foo & (Foo & Bar) = ...
+        // Because we are returning the implementation locations and not the identifier locations,
+        // duplicate entries would be returned here as each of the type references is part of
+        // the same implementation. For that reason, check before we add a new entry
+        function maybeAdd(a: ReferenceEntry) {
+            if (!forEach(result, b => a.fileName === b.fileName && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length)) {
+                result.push(a);
+            }
+        }
+    }
+
+    function getSymbolsForClassAndInterfaceComponents(type: UnionOrIntersectionType, result: Symbol[] = []): Symbol[] {
+        for (const componentType of type.types) {
+            if (componentType.symbol && componentType.symbol.getFlags() & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                result.push(componentType.symbol);
+            }
+            if (componentType.getFlags() & TypeFlags.UnionOrIntersection) {
+                getSymbolsForClassAndInterfaceComponents(<UnionOrIntersectionType>componentType, result);
+            }
+        }
+        return result;
+    }
+
+    function getContainingTypeReference(node: Node): Node {
+        let topLevelTypeReference: Node = undefined;
+
+        while (node) {
+            if (isTypeNode(node)) {
+                topLevelTypeReference = node;
+            }
+            node = node.parent;
+        }
+
+        return topLevelTypeReference;
+    }
+
+    function getContainingClassIfInHeritageClause(node: Node): ClassLikeDeclaration {
+        if (node && node.parent) {
+            if (node.kind === SyntaxKind.ExpressionWithTypeArguments
+                && node.parent.kind === SyntaxKind.HeritageClause
+                && isClassLike(node.parent.parent)) {
+                return node.parent.parent;
+            }
+
+            else if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PropertyAccessExpression) {
+                return getContainingClassIfInHeritageClause(node.parent);
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns true if this is an expression that can be considered an implementation
+     */
+    function isImplementationExpression(node: Expression): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ParenthesizedExpression:
                 return isImplementationExpression((<ParenthesizedExpression>node).expression);
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ObjectLiteralExpression:
+            case SyntaxKind.ClassExpression:
+            case SyntaxKind.ArrayLiteralExpression:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Determines if the parent symbol occurs somewhere in the child's ancestry. If the parent symbol
+     * is an interface, determines if some ancestor of the child symbol extends or inherits from it.
+     * Also takes in a cache of previous results which makes this slightly more efficient and is
+     * necessary to avoid potential loops like so:
+     *     class A extends B { }
+     *     class B extends A { }
+     *
+     * We traverse the AST rather than using the type checker because users are typically only interested
+     * in explicit implementations of an interface/class when calling "Go to Implementation". Sibling
+     * implementations of types that share a common ancestor with the type whose implementation we are
+     * searching for need to be filtered out of the results. The type checker doesn't let us make the
+     * distinction between structurally compatible implementations and explicit implementations, so we
+     * must use the AST.
+     *
+     * @param child         A class or interface Symbol
+     * @param parent        Another class or interface Symbol
+     * @param cachedResults A map of symbol id pairs (i.e. "child,parent") to booleans indicating previous results
+     */
+    function explicitlyInheritsFrom(child: Symbol, parent: Symbol, cachedResults: Map<boolean>, typeChecker: TypeChecker): boolean {
+        const parentIsInterface = parent.getFlags() & SymbolFlags.Interface;
+        return searchHierarchy(child);
+
+        function searchHierarchy(symbol: Symbol): boolean {
+            if (symbol === parent) {
+                return true;
             }
 
-            return node.kind === SyntaxKind.ArrowFunction ||
-                node.kind === SyntaxKind.FunctionExpression ||
-                node.kind === SyntaxKind.ObjectLiteralExpression ||
-                node.kind === SyntaxKind.ClassExpression ||
-                node.kind === SyntaxKind.ArrayLiteralExpression;
-        }
+            const key = getSymbolId(symbol) + "," + getSymbolId(parent);
+            if (key in cachedResults) {
+                return cachedResults[key];
+            }
 
-        /**
-         * Determines if the parent symbol occurs somewhere in the child's ancestry. If the parent symbol
-         * is an interface, determines if some ancestor of the child symbol extends or inherits from it.
-         * Also takes in a cache of previous results which makes this slightly more efficient and is
-         * necessary to avoid potential loops like so:
-         *     class A extends B { }
-         *     class B extends A { }
-         *
-         * We traverse the AST rather than using the type checker because users are typically only interested
-         * in explicit implementations of an interface/class when calling "Go to Implementation". Sibling
-         * implementations of types that share a common ancestor with the type whose implementation we are
-         * searching for need to be filtered out of the results. The type checker doesn't let us make the
-         * distinction between structurally compatible implementations and explicit implementations, so we
-         * must use the AST.
-         *
-         * @param child         A class or interface Symbol
-         * @param parent        Another class or interface Symbol
-         * @param cachedResults A map of symbol id pairs (i.e. "child,parent") to booleans indicating previous results
-         */
-        function explicitlyInheritsFrom(child: Symbol, parent: Symbol, cachedResults: Map<boolean>): boolean {
-            const parentIsInterface = parent.getFlags() & SymbolFlags.Interface;
-            return searchHierarchy(child);
+            // Set the key so that we don't infinitely recurse
+            cachedResults[key] = false;
 
-            function searchHierarchy(symbol: Symbol): boolean {
-                if (symbol === parent) {
-                    return true;
-                }
-
-                const key = getSymbolId(symbol) + "," + getSymbolId(parent);
-                if (key in cachedResults) {
-                    return cachedResults[key];
-                }
-
-                // Set the key so that we don't infinitely recurse
-                cachedResults[key] = false;
-
-                const inherits = forEach(symbol.getDeclarations(), declaration => {
-                    if (isClassLike(declaration)) {
-                        if (parentIsInterface) {
-                            const interfaceReferences = getClassImplementsHeritageClauseElements(declaration);
-                            if (interfaceReferences) {
-                                for (const typeReference of interfaceReferences) {
-                                    if (searchTypeReference(typeReference)) {
-                                        return true;
-                                    }
+            const inherits = forEach(symbol.getDeclarations(), declaration => {
+                if (isClassLike(declaration)) {
+                    if (parentIsInterface) {
+                        const interfaceReferences = getClassImplementsHeritageClauseElements(declaration);
+                        if (interfaceReferences) {
+                            for (const typeReference of interfaceReferences) {
+                                if (searchTypeReference(typeReference)) {
+                                    return true;
                                 }
                             }
                         }
-                        return searchTypeReference(getClassExtendsHeritageClauseElement(declaration));
                     }
-                    else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
-                        if (parentIsInterface) {
-                            return forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), searchTypeReference);
-                        }
-                    }
-                    return false;
-                });
-
-                cachedResults[key] = inherits;
-                return inherits;
-            }
-
-            function searchTypeReference(typeReference: ExpressionWithTypeArguments): boolean {
-                if (typeReference) {
-                    const type = typeChecker.getTypeAtLocation(typeReference);
-                    if (type && type.symbol) {
-                        return searchHierarchy(type.symbol);
+                    return searchTypeReference(getClassExtendsHeritageClauseElement(declaration));
+                }
+                else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
+                    if (parentIsInterface) {
+                        return forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), searchTypeReference);
                     }
                 }
                 return false;
-            }
+            });
+
+            cachedResults[key] = inherits;
+            return inherits;
         }
 
-        function getReferencesForSuperKeyword(superKeyword: Node): ReferencedSymbol[] {
-            let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false);
-            if (!searchSpaceNode) {
+        function searchTypeReference(typeReference: ExpressionWithTypeArguments): boolean {
+            if (typeReference) {
+                const type = typeChecker.getTypeAtLocation(typeReference);
+                if (type && type.symbol) {
+                    return searchHierarchy(type.symbol);
+                }
+            }
+            return false;
+        }
+    }
+
+    function getReferencesForSuperKeyword(superKeyword: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] {
+        let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false);
+        if (!searchSpaceNode) {
+            return undefined;
+        }
+        // Whether 'super' occurs in a static context within a class.
+        let staticFlag = ModifierFlags.Static;
+
+        switch (searchSpaceNode.kind) {
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.Constructor:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+                staticFlag &= getModifierFlags(searchSpaceNode);
+                searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
+                break;
+            default:
                 return undefined;
-            }
-            // Whether 'super' occurs in a static context within a class.
-            let staticFlag = ModifierFlags.Static;
+        }
 
-            switch (searchSpaceNode.kind) {
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    staticFlag &= getModifierFlags(searchSpaceNode);
-                    searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
+        const references: ReferenceEntry[] = [];
+
+        const sourceFile = searchSpaceNode.getSourceFile();
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken);
+        forEach(possiblePositions, position => {
+            cancellationToken.throwIfCancellationRequested();
+
+            const node = getTouchingWord(sourceFile, position);
+
+            if (!node || node.kind !== SyntaxKind.SuperKeyword) {
+                return;
+            }
+
+            const container = getSuperContainer(node, /*stopOnFunctions*/ false);
+
+            // If we have a 'super' container, we must have an enclosing class.
+            // Now make sure the owning class is the same as the search-space
+            // and has the same static qualifier as the original 'super's owner.
+            if (container && (ModifierFlags.Static & getModifierFlags(container)) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
+                references.push(getReferenceEntryFromNode(node));
+            }
+        });
+
+        const definition = getDefinition(searchSpaceNode.symbol, superKeyword, typeChecker);
+        return [{ definition, references }];
+    }
+
+    function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] {
+        let searchSpaceNode = getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
+
+        // Whether 'this' occurs in a static context within a class.
+        let staticFlag = ModifierFlags.Static;
+
+        switch (searchSpaceNode.kind) {
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+                if (isObjectLiteralMethod(searchSpaceNode)) {
                     break;
-                default:
+                }
+            // fall through
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.Constructor:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+                staticFlag &= getModifierFlags(searchSpaceNode);
+                searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
+                break;
+            case SyntaxKind.SourceFile:
+                if (isExternalModule(<SourceFile>searchSpaceNode)) {
                     return undefined;
-            }
+                }
+            // Fall through
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.FunctionExpression:
+                break;
+            // Computed properties in classes are not handled here because references to this are illegal,
+            // so there is no point finding references to them.
+            default:
+                return undefined;
+        }
 
-            const references: ReferenceEntry[] = [];
+        const references: ReferenceEntry[] = [];
 
+        let possiblePositions: number[];
+        if (searchSpaceNode.kind === SyntaxKind.SourceFile) {
+            forEach(sourceFiles, sourceFile => {
+                possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
+                getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references);
+            });
+        }
+        else {
             const sourceFile = searchSpaceNode.getSourceFile();
-            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd());
+            possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken);
+            getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references);
+        }
+
+        const thisOrSuperSymbol = typeChecker.getSymbolAtLocation(thisOrSuperKeyword);
+
+        const displayParts = thisOrSuperSymbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(
+            typeChecker, thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts;
+
+        return [{
+            definition: {
+                containerKind: "",
+                containerName: "",
+                fileName: thisOrSuperKeyword.getSourceFile().fileName,
+                kind: ScriptElementKind.variableElement,
+                name: "this",
+                textSpan: createTextSpanFromNode(thisOrSuperKeyword),
+                displayParts
+            },
+            references: references
+        }];
+
+        function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: ReferenceEntry[]): void {
             forEach(possiblePositions, position => {
                 cancellationToken.throwIfCancellationRequested();
 
                 const node = getTouchingWord(sourceFile, position);
-
-                if (!node || node.kind !== SyntaxKind.SuperKeyword) {
+                if (!node || !isThis(node)) {
                     return;
                 }
 
-                const container = getSuperContainer(node, /*stopOnFunctions*/ false);
+                const container = getThisContainer(node, /* includeArrowFunctions */ false);
 
-                // If we have a 'super' container, we must have an enclosing class.
-                // Now make sure the owning class is the same as the search-space
-                // and has the same static qualifier as the original 'super's owner.
-                if (container && (ModifierFlags.Static & getModifierFlags(container)) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
-                    references.push(getReferenceEntryFromNode(node));
-                }
-            });
-
-            const definition = getDefinition(searchSpaceNode.symbol);
-            return [{ definition, references }];
-        }
-
-        function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[]): ReferencedSymbol[] {
-            let searchSpaceNode = getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
-
-            // Whether 'this' occurs in a static context within a class.
-            let staticFlag = ModifierFlags.Static;
-
-            switch (searchSpaceNode.kind) {
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                    if (isObjectLiteralMethod(searchSpaceNode)) {
+                switch (searchSpaceNode.kind) {
+                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.FunctionDeclaration:
+                        if (searchSpaceNode.symbol === container.symbol) {
+                            result.push(getReferenceEntryFromNode(node));
+                        }
+                        break;
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                        if (isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) {
+                            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.
+                        if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (getModifierFlags(container) & ModifierFlags.Static) === staticFlag) {
+                            result.push(getReferenceEntryFromNode(node));
+                        }
+                        break;
+                    case SyntaxKind.SourceFile:
+                        if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
+                            result.push(getReferenceEntryFromNode(node));
+                        }
                         break;
-                    }
-                // fall through
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    staticFlag &= getModifierFlags(searchSpaceNode);
-                    searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class
-                    break;
-                case SyntaxKind.SourceFile:
-                    if (isExternalModule(<SourceFile>searchSpaceNode)) {
-                        return undefined;
-                    }
-                // Fall through
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.FunctionExpression:
-                    break;
-                // Computed properties in classes are not handled here because references to this are illegal,
-                // so there is no point finding references to them.
-                default:
-                    return undefined;
-            }
-
-            const references: ReferenceEntry[] = [];
-
-            let possiblePositions: number[];
-            if (searchSpaceNode.kind === SyntaxKind.SourceFile) {
-                forEach(sourceFiles, sourceFile => {
-                    possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd());
-                    getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, references);
-                });
-            }
-            else {
-                const sourceFile = searchSpaceNode.getSourceFile();
-                possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd());
-                getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references);
-            }
-
-            const thisOrSuperSymbol = typeChecker.getSymbolAtLocation(thisOrSuperKeyword);
-
-            const displayParts = thisOrSuperSymbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(
-                typeChecker, thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts;
-
-            return [{
-                definition: {
-                    containerKind: "",
-                    containerName: "",
-                    fileName: node.getSourceFile().fileName,
-                    kind: ScriptElementKind.variableElement,
-                    name: "this",
-                    textSpan: createTextSpanFromNode(node),
-                    displayParts
-                },
-                references: references
-            }];
-
-            function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: ReferenceEntry[]): void {
-                forEach(possiblePositions, position => {
-                    cancellationToken.throwIfCancellationRequested();
-
-                    const node = getTouchingWord(sourceFile, position);
-                    if (!node || !isThis(node)) {
-                        return;
-                    }
-
-                    const container = getThisContainer(node, /* includeArrowFunctions */ false);
-
-                    switch (searchSpaceNode.kind) {
-                        case SyntaxKind.FunctionExpression:
-                        case SyntaxKind.FunctionDeclaration:
-                            if (searchSpaceNode.symbol === container.symbol) {
-                                result.push(getReferenceEntryFromNode(node));
-                            }
-                            break;
-                        case SyntaxKind.MethodDeclaration:
-                        case SyntaxKind.MethodSignature:
-                            if (isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) {
-                                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.
-                            if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (getModifierFlags(container) & ModifierFlags.Static) === staticFlag) {
-                                result.push(getReferenceEntryFromNode(node));
-                            }
-                            break;
-                        case SyntaxKind.SourceFile:
-                            if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
-                                result.push(getReferenceEntryFromNode(node));
-                            }
-                            break;
-                    }
-                });
-            }
-        }
-
-
-        function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[]): ReferencedSymbol[] {
-            const type = getStringLiteralTypeForNode(node, typeChecker);
-
-            if (!type) {
-                // nothing to do here. moving on
-                return undefined;
-            }
-
-            const references: ReferenceEntry[] = [];
-
-            for (const sourceFile of sourceFiles) {
-                const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd());
-                getReferencesForStringLiteralInFile(sourceFile, type, possiblePositions, references);
-            }
-
-            return [{
-                definition: {
-                    containerKind: "",
-                    containerName: "",
-                    fileName: node.getSourceFile().fileName,
-                    kind: ScriptElementKind.variableElement,
-                    name: type.text,
-                    textSpan: createTextSpanFromNode(node),
-                    displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)]
-                },
-                references: references
-            }];
-
-            function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: ReferenceEntry[]): void {
-                for (const position of possiblePositions) {
-                    cancellationToken.throwIfCancellationRequested();
-
-                    const node = getTouchingWord(sourceFile, position);
-                    if (!node || node.kind !== SyntaxKind.StringLiteral) {
-                        return;
-                    }
-
-                    const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
-                    if (type === searchType) {
-                        references.push(getReferenceEntryFromNode(node));
-                    }
-                }
-            }
-        }
-
-        function populateSearchSymbolSet(symbol: Symbol, location: Node): Symbol[] {
-            // The search set contains at least the current symbol
-            let result = [symbol];
-
-            // If the location is name of property symbol from object literal destructuring pattern
-            // Search the property symbol
-            //      for ( { property: p2 } of elems) { }
-            const containingObjectLiteralElement = getContainingObjectLiteralElement(location);
-            if (containingObjectLiteralElement && containingObjectLiteralElement.kind !== SyntaxKind.ShorthandPropertyAssignment) {
-                const propertySymbol = getPropertySymbolOfDestructuringAssignment(location);
-                if (propertySymbol) {
-                    result.push(propertySymbol);
-                }
-            }
-
-            // If the symbol is an alias, add what it aliases to the list
-            //     import {a} from "mod";
-            //     export {a}
-            // If the symbol is an alias to default declaration, add what it aliases to the list
-            //     declare "mod" { export default class B { } }
-            //     import B from "mod";
-            //// For export specifiers, the exported name can be referring to a local symbol, e.g.:
-            ////     import {a} from "mod";
-            ////     export {a as somethingElse}
-            //// We want the *local* declaration of 'a' as declared in the import,
-            //// *not* as declared within "mod" (or farther)
-            const aliasSymbol = getAliasSymbolForPropertyNameSymbol(symbol, location);
-            if (aliasSymbol) {
-                result = result.concat(populateSearchSymbolSet(aliasSymbol, location));
-            }
-
-            // If the location is in a context sensitive location (i.e. in an object literal) try
-            // to get a contextual type for it, and add the property symbol from the contextual
-            // type to the search set
-            if (containingObjectLiteralElement) {
-                forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement), contextualSymbol => {
-                    addRange(result, typeChecker.getRootSymbols(contextualSymbol));
-                });
-
-                /* Because in short-hand property assignment, location has two meaning : property name and as value of the property
-                    * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of
-                    * property name and variable declaration of the identifier.
-                    * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service
-                    * should show both 'name' in 'obj' and 'name' in variable declaration
-                    *      const name = "Foo";
-                    *      const obj = { name };
-                    * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment
-                    * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration
-                    * will be included correctly.
-                    */
-                const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(location.parent);
-                if (shorthandValueSymbol) {
-                    result.push(shorthandValueSymbol);
-                }
-            }
-
-            // If the symbol.valueDeclaration is a property parameter declaration,
-            // we should include both parameter declaration symbol and property declaration symbol
-            // Parameter Declaration symbol is only visible within function scope, so the symbol is stored in constructor.locals.
-            // Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members
-            if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.Parameter &&
-                isParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration)) {
-                result = result.concat(typeChecker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
-            }
-
-            // If this is symbol of binding element without propertyName declaration in Object binding pattern
-            // Include the property in the search
-            const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol);
-            if (bindingElementPropertySymbol) {
-                result.push(bindingElementPropertySymbol);
-            }
-
-            // If this is a union property, add all the symbols from all its source symbols in all unioned types.
-            // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
-            forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
-                if (rootSymbol !== symbol) {
-                    result.push(rootSymbol);
-                }
-
-                // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
-                if (!implementations && rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                    getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>());
                 }
             });
-
-            return result;
         }
+    }
 
-        /**
-         * Find symbol of the given property-name and add the symbol to the given result array
-         * @param symbol a symbol to start searching for the given propertyName
-         * @param propertyName a name of property to search for
-         * @param result an array of symbol of found property symbols
-         * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol.
-         *                                The value of previousIterationSymbol is undefined when the function is first called.
-         */
-        function getPropertySymbolsFromBaseTypes(symbol: Symbol, propertyName: string, result: Symbol[],
-            previousIterationSymbolsCache: SymbolTable): void {
-            if (!symbol) {
-                return;
-            }
+    function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] {
+        const type = getStringLiteralTypeForNode(node, typeChecker);
 
-            // If the current symbol is the same as the previous-iteration symbol, we can just return the symbol that has already been visited
-            // This is particularly important for the following cases, so that we do not infinitely visit the same symbol.
-            // For example:
-            //      interface C extends C {
-            //          /*findRef*/propName: string;
-            //      }
-            // The first time getPropertySymbolsFromBaseTypes is called when finding-all-references at propName,
-            // the symbol argument will be the symbol of an interface "C" and previousIterationSymbol is undefined,
-            // the function will add any found symbol of the property-name, then its sub-routine will call
-            // getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
-            // visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
-            if (symbol.name in previousIterationSymbolsCache) {
-                return;
-            }
-
-            if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                forEach(symbol.getDeclarations(), declaration => {
-                    if (isClassLike(declaration)) {
-                        getPropertySymbolFromTypeReference(getClassExtendsHeritageClauseElement(<ClassDeclaration>declaration));
-                        forEach(getClassImplementsHeritageClauseElements(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
-                    }
-                    else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
-                        forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), getPropertySymbolFromTypeReference);
-                    }
-                });
-            }
-            return;
-
-            function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments) {
-                if (typeReference) {
-                    const type = typeChecker.getTypeAtLocation(typeReference);
-                    if (type) {
-                        const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
-                        if (propertySymbol) {
-                            result.push(...typeChecker.getRootSymbols(propertySymbol));
-                        }
-
-                        // Visit the typeReference as well to see if it directly or indirectly use that property
-                        previousIterationSymbolsCache[symbol.name] = symbol;
-                        getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache);
-                    }
-                }
-            }
-        }
-
-        function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>): Symbol {
-            if (contains(searchSymbols, referenceSymbol)) {
-                // If we are searching for constructor uses, they must be 'new' expressions.
-                return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) && referenceSymbol;
-            }
-
-            // If the reference symbol is an alias, check if what it is aliasing is one of the search
-            // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness.
-            const aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation);
-            if (aliasSymbol) {
-                return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache);
-            }
-
-            // If the reference location is in an object literal, try to get the contextual type for the
-            // object literal, lookup the property symbol in the contextual type, and use this symbol to
-            // compare to our searchSymbol
-            const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
-            if (containingObjectLiteralElement) {
-                const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement), contextualSymbol => {
-                    return forEach(typeChecker.getRootSymbols(contextualSymbol), s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
-                });
-
-                if (contextualSymbol) {
-                    return contextualSymbol;
-                }
-
-                // If the reference location is the name of property from object literal destructuring pattern
-                // Get the property symbol from the object literal's type and look if thats the search symbol
-                // In below eg. get 'property' from type of elems iterating type
-                //      for ( { property: p2 } of elems) { }
-                const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation);
-                if (propertySymbol && searchSymbols.indexOf(propertySymbol) >= 0) {
-                    return propertySymbol;
-                }
-            }
-
-            // If the reference location is the binding element and doesn't have property name
-            // then include the binding element in the related symbols
-            //      let { a } : { a };
-            const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol);
-            if (bindingElementPropertySymbol && searchSymbols.indexOf(bindingElementPropertySymbol) >= 0) {
-                return bindingElementPropertySymbol;
-            }
-
-            // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening)
-            // Or a union property, use its underlying unioned symbols
-            return forEach(typeChecker.getRootSymbols(referenceSymbol), rootSymbol => {
-                // if it is in the list, then we are done
-                if (searchSymbols.indexOf(rootSymbol) >= 0) {
-                    return rootSymbol;
-                }
-
-                // Finally, try all properties with the same name in any type the containing type extended or implemented, and
-                // see if any is in the list. If we were passed a parent symbol, only include types that are subtypes of the
-                // parent symbol
-                if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                    // Parents will only be defined if implementations is true
-                    if (parents) {
-                        if (!forEach(parents, parent => explicitlyInheritsFrom(rootSymbol.parent, parent, cache))) {
-                            return undefined;
-                        }
-                    }
-
-                    const result: Symbol[] = [];
-                    getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>());
-                    return forEach(result, s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
-                }
-
-                return undefined;
-            });
-        }
-
-        function getNameFromObjectLiteralElement(node: ObjectLiteralElement) {
-            if (node.name.kind === SyntaxKind.ComputedPropertyName) {
-                const nameExpression = (<ComputedPropertyName>node.name).expression;
-                // treat computed property names where expression is string/numeric literal as just string/numeric literal
-                if (isStringOrNumericLiteral(nameExpression)) {
-                    return (<LiteralExpression>nameExpression).text;
-                }
-                return undefined;
-            }
-            return (<Identifier | LiteralExpression>node.name).text;
-        }
-
-        function getPropertySymbolsFromContextualType(node: ObjectLiteralElement): Symbol[] {
-            const objectLiteral = <ObjectLiteralExpression>node.parent;
-            const contextualType = typeChecker.getContextualType(objectLiteral);
-            const name = getNameFromObjectLiteralElement(node);
-            if (name && contextualType) {
-                const result: Symbol[] = [];
-                const symbol = contextualType.getProperty(name);
-                if (symbol) {
-                    result.push(symbol);
-                }
-
-                if (contextualType.flags & TypeFlags.Union) {
-                    forEach((<UnionType>contextualType).types, t => {
-                        const symbol = t.getProperty(name);
-                        if (symbol) {
-                            result.push(symbol);
-                        }
-                    });
-                }
-                return result;
-            }
+        if (!type) {
+            // nothing to do here. moving on
             return undefined;
         }
 
-        /** Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations
-             * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class
-            * then we need to widen the search to include type positions as well.
-            * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated
-            * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module)
-            * do not intersect in any of the three spaces.
-            */
-        function getIntersectingMeaningFromDeclarations(meaning: SemanticMeaning, declarations: Declaration[]): SemanticMeaning {
-            if (declarations) {
-                let lastIterationMeaning: SemanticMeaning;
-                do {
-                    // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module]
-                    // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module
-                    // intersects with the class in the value space.
-                    // To achieve that we will keep iterating until the result stabilizes.
+        const references: ReferenceEntry[] = [];
 
-                    // Remember the last meaning
-                    lastIterationMeaning = meaning;
+        for (const sourceFile of sourceFiles) {
+            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
+            getReferencesForStringLiteralInFile(sourceFile, type, possiblePositions, references);
+        }
 
-                    for (const declaration of declarations) {
-                        const declarationMeaning = getMeaningFromDeclaration(declaration);
+        return [{
+            definition: {
+                containerKind: "",
+                containerName: "",
+                fileName: node.getSourceFile().fileName,
+                kind: ScriptElementKind.variableElement,
+                name: type.text,
+                textSpan: createTextSpanFromNode(node),
+                displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)]
+            },
+            references: references
+        }];
 
-                        if (declarationMeaning & meaning) {
-                            meaning |= declarationMeaning;
-                        }
+        function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: ReferenceEntry[]): void {
+            for (const position of possiblePositions) {
+                cancellationToken.throwIfCancellationRequested();
+
+                const node = getTouchingWord(sourceFile, position);
+                if (!node || node.kind !== SyntaxKind.StringLiteral) {
+                    return;
+                }
+
+                const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
+                if (type === searchType) {
+                    references.push(getReferenceEntryFromNode(node));
+                }
+            }
+        }
+    }
+
+    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean): Symbol[] {
+        // The search set contains at least the current symbol
+        let result = [symbol];
+
+        // If the location is name of property symbol from object literal destructuring pattern
+        // Search the property symbol
+        //      for ( { property: p2 } of elems) { }
+        const containingObjectLiteralElement = getContainingObjectLiteralElement(location);
+        if (containingObjectLiteralElement && containingObjectLiteralElement.kind !== SyntaxKind.ShorthandPropertyAssignment) {
+            const propertySymbol = getPropertySymbolOfDestructuringAssignment(location, typeChecker);
+            if (propertySymbol) {
+                result.push(propertySymbol);
+            }
+        }
+
+        // If the symbol is an alias, add what it aliases to the list
+        //     import {a} from "mod";
+        //     export {a}
+        // If the symbol is an alias to default declaration, add what it aliases to the list
+        //     declare "mod" { export default class B { } }
+        //     import B from "mod";
+        //// For export specifiers, the exported name can be referring to a local symbol, e.g.:
+        ////     import {a} from "mod";
+        ////     export {a as somethingElse}
+        //// We want the *local* declaration of 'a' as declared in the import,
+        //// *not* as declared within "mod" (or farther)
+        const aliasSymbol = getAliasSymbolForPropertyNameSymbol(symbol, location, typeChecker);
+        if (aliasSymbol) {
+            result = result.concat(populateSearchSymbolSet(aliasSymbol, location, typeChecker, implementations));
+        }
+
+        // If the location is in a context sensitive location (i.e. in an object literal) try
+        // to get a contextual type for it, and add the property symbol from the contextual
+        // type to the search set
+        if (containingObjectLiteralElement) {
+            forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol => {
+                addRange(result, typeChecker.getRootSymbols(contextualSymbol));
+            });
+
+            /* Because in short-hand property assignment, location has two meaning : property name and as value of the property
+                * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of
+                * property name and variable declaration of the identifier.
+                * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service
+                * should show both 'name' in 'obj' and 'name' in variable declaration
+                *      const name = "Foo";
+                *      const obj = { name };
+                * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment
+                * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration
+                * will be included correctly.
+                */
+            const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(location.parent);
+            if (shorthandValueSymbol) {
+                result.push(shorthandValueSymbol);
+            }
+        }
+
+        // If the symbol.valueDeclaration is a property parameter declaration,
+        // we should include both parameter declaration symbol and property declaration symbol
+        // Parameter Declaration symbol is only visible within function scope, so the symbol is stored in constructor.locals.
+        // Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members
+        if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.Parameter &&
+            isParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration)) {
+            result = result.concat(typeChecker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
+        }
+
+        // If this is symbol of binding element without propertyName declaration in Object binding pattern
+        // Include the property in the search
+        const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, typeChecker);
+        if (bindingElementPropertySymbol) {
+            result.push(bindingElementPropertySymbol);
+        }
+
+        // If this is a union property, add all the symbols from all its source symbols in all unioned types.
+        // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
+        forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
+            if (rootSymbol !== symbol) {
+                result.push(rootSymbol);
+            }
+
+            // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
+            if (!implementations && rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
+            }
+        });
+
+        return result;
+    }
+
+    /**
+     * Find symbol of the given property-name and add the symbol to the given result array
+     * @param symbol a symbol to start searching for the given propertyName
+     * @param propertyName a name of property to search for
+     * @param result an array of symbol of found property symbols
+     * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol.
+     *                                The value of previousIterationSymbol is undefined when the function is first called.
+     */
+    function getPropertySymbolsFromBaseTypes(symbol: Symbol, propertyName: string, result: Symbol[],
+        previousIterationSymbolsCache: SymbolTable, typeChecker: TypeChecker): void {
+        if (!symbol) {
+            return;
+        }
+
+        // If the current symbol is the same as the previous-iteration symbol, we can just return the symbol that has already been visited
+        // This is particularly important for the following cases, so that we do not infinitely visit the same symbol.
+        // For example:
+        //      interface C extends C {
+        //          /*findRef*/propName: string;
+        //      }
+        // The first time getPropertySymbolsFromBaseTypes is called when finding-all-references at propName,
+        // the symbol argument will be the symbol of an interface "C" and previousIterationSymbol is undefined,
+        // the function will add any found symbol of the property-name, then its sub-routine will call
+        // getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
+        // visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
+        if (symbol.name in previousIterationSymbolsCache) {
+            return;
+        }
+
+        if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+            forEach(symbol.getDeclarations(), declaration => {
+                if (isClassLike(declaration)) {
+                    getPropertySymbolFromTypeReference(getClassExtendsHeritageClauseElement(<ClassDeclaration>declaration));
+                    forEach(getClassImplementsHeritageClauseElements(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
+                }
+                else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
+                    forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), getPropertySymbolFromTypeReference);
+                }
+            });
+        }
+        return;
+
+        function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments) {
+            if (typeReference) {
+                const type = typeChecker.getTypeAtLocation(typeReference);
+                if (type) {
+                    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+                    if (propertySymbol) {
+                        result.push(...typeChecker.getRootSymbols(propertySymbol));
+                    }
+
+                    // Visit the typeReference as well to see if it directly or indirectly use that property
+                    previousIterationSymbolsCache[symbol.name] = symbol;
+                    getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, typeChecker);
+                }
+            }
+        }
+    }
+
+    function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>, typeChecker: TypeChecker): Symbol {
+        if (contains(searchSymbols, referenceSymbol)) {
+            // If we are searching for constructor uses, they must be 'new' expressions.
+            return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) && referenceSymbol;
+        }
+
+        // If the reference symbol is an alias, check if what it is aliasing is one of the search
+        // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness.
+        const aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation, typeChecker);
+        if (aliasSymbol) {
+            return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker);
+        }
+
+        // If the reference location is in an object literal, try to get the contextual type for the
+        // object literal, lookup the property symbol in the contextual type, and use this symbol to
+        // compare to our searchSymbol
+        const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
+        if (containingObjectLiteralElement) {
+            const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol => {
+                return forEach(typeChecker.getRootSymbols(contextualSymbol), s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
+            });
+
+            if (contextualSymbol) {
+                return contextualSymbol;
+            }
+
+            // If the reference location is the name of property from object literal destructuring pattern
+            // Get the property symbol from the object literal's type and look if thats the search symbol
+            // In below eg. get 'property' from type of elems iterating type
+            //      for ( { property: p2 } of elems) { }
+            const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, typeChecker);
+            if (propertySymbol && searchSymbols.indexOf(propertySymbol) >= 0) {
+                return propertySymbol;
+            }
+        }
+
+        // If the reference location is the binding element and doesn't have property name
+        // then include the binding element in the related symbols
+        //      let { a } : { a };
+        const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, typeChecker);
+        if (bindingElementPropertySymbol && searchSymbols.indexOf(bindingElementPropertySymbol) >= 0) {
+            return bindingElementPropertySymbol;
+        }
+
+        // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening)
+        // Or a union property, use its underlying unioned symbols
+        return forEach(typeChecker.getRootSymbols(referenceSymbol), rootSymbol => {
+            // if it is in the list, then we are done
+            if (searchSymbols.indexOf(rootSymbol) >= 0) {
+                return rootSymbol;
+            }
+
+            // Finally, try all properties with the same name in any type the containing type extended or implemented, and
+            // see if any is in the list. If we were passed a parent symbol, only include types that are subtypes of the
+            // parent symbol
+            if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                // Parents will only be defined if implementations is true
+                if (parents) {
+                    if (!forEach(parents, parent => explicitlyInheritsFrom(rootSymbol.parent, parent, cache, typeChecker))) {
+                        return undefined;
                     }
                 }
-                while (meaning !== lastIterationMeaning);
+
+                const result: Symbol[] = [];
+                getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
+                return forEach(result, s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
             }
-            return meaning;
+
+            return undefined;
+        });
+    }
+
+    function getNameFromObjectLiteralElement(node: ObjectLiteralElement) {
+        if (node.name.kind === SyntaxKind.ComputedPropertyName) {
+            const nameExpression = (<ComputedPropertyName>node.name).expression;
+            // treat computed property names where expression is string/numeric literal as just string/numeric literal
+            if (isStringOrNumericLiteral(nameExpression)) {
+                return (<LiteralExpression>nameExpression).text;
+            }
+            return undefined;
         }
+        return (<Identifier | LiteralExpression>node.name).text;
+    }
+
+    function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] {
+        const objectLiteral = <ObjectLiteralExpression>node.parent;
+        const contextualType = typeChecker.getContextualType(objectLiteral);
+        const name = getNameFromObjectLiteralElement(node);
+        if (name && contextualType) {
+            const result: Symbol[] = [];
+            const symbol = contextualType.getProperty(name);
+            if (symbol) {
+                result.push(symbol);
+            }
+
+            if (contextualType.flags & TypeFlags.Union) {
+                forEach((<UnionType>contextualType).types, t => {
+                    const symbol = t.getProperty(name);
+                    if (symbol) {
+                        result.push(symbol);
+                    }
+                });
+            }
+            return result;
+        }
+        return undefined;
+    }
+
+    /**
+     * Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations
+     * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class
+     * then we need to widen the search to include type positions as well.
+     * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated
+     * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module)
+     * do not intersect in any of the three spaces.
+     */
+    function getIntersectingMeaningFromDeclarations(meaning: SemanticMeaning, declarations: Declaration[]): SemanticMeaning {
+        if (declarations) {
+            let lastIterationMeaning: SemanticMeaning;
+            do {
+                // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module]
+                // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module
+                // intersects with the class in the value space.
+                // To achieve that we will keep iterating until the result stabilizes.
+
+                // Remember the last meaning
+                lastIterationMeaning = meaning;
+
+                for (const declaration of declarations) {
+                    const declarationMeaning = getMeaningFromDeclaration(declaration);
+
+                    if (declarationMeaning & meaning) {
+                        meaning |= declarationMeaning;
+                    }
+                }
+            }
+            while (meaning !== lastIterationMeaning);
+        }
+        return meaning;
     }
 
     export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
diff --git a/tests/cases/fourslash/findAllRefsForRest.ts b/tests/cases/fourslash/findAllRefsForRest.ts
index c3a970e9e73..65d6a3c60e3 100644
--- a/tests/cases/fourslash/findAllRefsForRest.ts
+++ b/tests/cases/fourslash/findAllRefsForRest.ts
@@ -7,6 +7,5 @@
 ////let t: Gen;
 ////var { x, ...rest } = t;
 ////rest.[|parent|];
-const ranges = test.ranges();
-verify.referencesOf(ranges[0], ranges);
-verify.referencesOf(ranges[1], ranges);
+
+verify.rangesReferenceEachOther();

From f1b481a1b61cd0808317b78c9a19acaea1eefa77 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 13 Jan 2017 14:08:44 -0800
Subject: [PATCH 046/159] Support completions for string literal in rest
 parameter

---
 src/compiler/checker.ts                              |  1 +
 src/compiler/types.ts                                |  5 +++++
 src/services/completions.ts                          |  5 +----
 tests/cases/fourslash/completionForStringLiteral7.ts | 10 ++++++++++
 4 files changed, 17 insertions(+), 4 deletions(-)
 create mode 100644 tests/cases/fourslash/completionForStringLiteral7.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a916e9cbba6..dbb1b53efc1 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -84,6 +84,7 @@ namespace ts {
             getIndexTypeOfType,
             getBaseTypes,
             getTypeFromTypeNode,
+            getParameterType: getTypeAtPosition,
             getReturnTypeOfSignature,
             getNonNullableType,
             getSymbolsInScope,
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 0906488ea33..23c55aacf26 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2341,6 +2341,11 @@ namespace ts {
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
         getBaseTypes(type: InterfaceType): ObjectType[];
         getReturnTypeOfSignature(signature: Signature): Type;
+        /**
+         * Gets the type of a parameter at a given position in a signature.
+         * Returns `any` if the index is not valid.
+         */
+        /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type;
         getNonNullableType(type: Type): Type;
 
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
diff --git a/src/services/completions.ts b/src/services/completions.ts
index bb5922af9ad..8c0d52b2c34 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -204,10 +204,7 @@ namespace ts.Completions {
             typeChecker.getResolvedSignature(argumentInfo.invocation, candidates);
 
             for (const candidate of candidates) {
-                if (candidate.parameters.length > argumentInfo.argumentIndex) {
-                    const parameter = candidate.parameters[argumentInfo.argumentIndex];
-                    addStringLiteralCompletionsFromType(typeChecker.getTypeAtLocation(parameter.valueDeclaration), entries);
-                }
+                addStringLiteralCompletionsFromType(typeChecker.getParameterType(candidate, argumentInfo.argumentIndex), entries);
             }
 
             if (entries.length) {
diff --git a/tests/cases/fourslash/completionForStringLiteral7.ts b/tests/cases/fourslash/completionForStringLiteral7.ts
new file mode 100644
index 00000000000..b2d250ac3fd
--- /dev/null
+++ b/tests/cases/fourslash/completionForStringLiteral7.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts'/>
+
+////type T = "foo" | "bar";
+////type U = "oof" | "rab";
+////function f(x: T, ...args: U[]) { };
+////f("/*1*/", "/*2*/", "/*3*/");
+
+verify.completionsAt("1", ["foo", "bar"]);
+verify.completionsAt("2", ["oof", "rab"]);
+verify.completionsAt("3", ["oof", "rab"]);

From bc7f86c1df771ed2cce7f784eca9cde6ea26cb45 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 15:05:08 -0800
Subject: [PATCH 047/159] Improved undefined/null handling for arithmetic
 operators

---
 src/compiler/checker.ts | 47 ++++++++++++++++-------------------------
 1 file changed, 18 insertions(+), 29 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9e4e81e3da9..cb48b2176f9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -12332,16 +12332,18 @@ namespace ts {
         }
 
         function checkNonNullExpression(node: Expression | QualifiedName) {
-            const type = checkExpression(node);
-            if (strictNullChecks) {
-                const kind = getFalsyFlags(type) & TypeFlags.Nullable;
-                if (kind) {
-                    error(node, kind & TypeFlags.Undefined ? kind & TypeFlags.Null ?
-                        Diagnostics.Object_is_possibly_null_or_undefined :
-                        Diagnostics.Object_is_possibly_undefined :
-                        Diagnostics.Object_is_possibly_null);
-                }
-                return getNonNullableType(type);
+            return checkNonNullType(checkExpression(node), node);
+        }
+
+        function checkNonNullType(type: Type, errorNode: Node): Type {
+            const kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & TypeFlags.Nullable;
+            if (kind) {
+                error(errorNode, kind & TypeFlags.Undefined ? kind & TypeFlags.Null ?
+                    Diagnostics.Object_is_possibly_null_or_undefined :
+                    Diagnostics.Object_is_possibly_undefined :
+                    Diagnostics.Object_is_possibly_null);
+                const t = getNonNullableType(type);
+                return t.flags & (TypeFlags.Nullable | TypeFlags.Never) ? unknownType : t;
             }
             return type;
         }
@@ -14880,17 +14882,9 @@ namespace ts {
                     if (leftType === silentNeverType || rightType === silentNeverType) {
                         return silentNeverType;
                     }
-                    // TypeScript 1.0 spec (April 2014): 4.19.1
-                    // These operators require their operands to be of type Any, the Number primitive type,
-                    // or an enum type. Operands of an enum type are treated
-                    // as having the primitive type Number. If one operand is the null or undefined value,
-                    // it is treated as having the type of the other operand.
-                    // The result is always of the Number primitive type.
-                    if (leftType.flags & TypeFlags.Nullable) leftType = rightType;
-                    if (rightType.flags & TypeFlags.Nullable) rightType = leftType;
 
-                    leftType = getNonNullableType(leftType);
-                    rightType = getNonNullableType(rightType);
+                    leftType = checkNonNullType(leftType, left);
+                    rightType = checkNonNullType(rightType, right);
 
                     let suggestedOperator: SyntaxKind;
                     // if a user tries to apply a bitwise operator to 2 boolean operands
@@ -14915,16 +14909,11 @@ namespace ts {
                     if (leftType === silentNeverType || rightType === silentNeverType) {
                         return silentNeverType;
                     }
-                    // TypeScript 1.0 spec (April 2014): 4.19.2
-                    // The binary + operator requires both operands to be of the Number primitive type or an enum type,
-                    // or at least one of the operands to be of type Any or the String primitive type.
 
-                    // If one operand is the null or undefined value, it is treated as having the type of the other operand.
-                    if (leftType.flags & TypeFlags.Nullable) leftType = rightType;
-                    if (rightType.flags & TypeFlags.Nullable) rightType = leftType;
-
-                    leftType = getNonNullableType(leftType);
-                    rightType = getNonNullableType(rightType);
+                    if (!isTypeOfKind(leftType, TypeFlags.Any | TypeFlags.StringLike) && !isTypeOfKind(rightType, TypeFlags.Any | TypeFlags.StringLike)) {
+                        leftType = checkNonNullType(leftType, left);
+                        rightType = checkNonNullType(rightType, right);
+                    }
 
                     let resultType: Type;
                     if (isTypeOfKind(leftType, TypeFlags.NumberLike) && isTypeOfKind(rightType, TypeFlags.NumberLike)) {

From a1e16d2cb492bbe49ead4baddc98b720ca63b35f Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 15:06:24 -0800
Subject: [PATCH 048/159] Accept new baselines

---
 ...WithNullValueAndInvalidOperator.errors.txt |  66 +--
 ...orWithNullValueAndValidOperator.errors.txt |  63 ++
 ...thOnlyNullValueOrUndefinedValue.errors.txt |  38 +-
 ...ditionOperatorWithTypeParameter.errors.txt |  12 +-
 ...ndefinedValueAndInvalidOperands.errors.txt |  66 +--
 ...hUndefinedValueAndValidOperator.errors.txt |  63 ++
 .../ambientWithStatements.errors.txt          |   4 +-
 ...WithNullValueAndInvalidOperands.errors.txt | 542 ++++++++++--------
 ...orWithNullValueAndValidOperands.errors.txt | 353 ++++++++++++
 ...thOnlyNullValueOrUndefinedValue.errors.txt | 320 +++++------
 ...ndefinedValueAndInvalidOperands.errors.txt | 542 ++++++++++--------
 ...hUndefinedValueAndValidOperands.errors.txt | 353 ++++++++++++
 .../reference/binaryArithmatic1.errors.txt    |   7 +
 .../reference/binaryArithmatic2.errors.txt    |   7 +
 .../reference/binaryArithmatic3.errors.txt    |   8 +-
 .../reference/binaryArithmatic4.errors.txt    |   8 +-
 ...wiseNotOperatorWithAnyOtherType.errors.txt |  29 +-
 ...itionAssignmentLHSCanBeAssigned.errors.txt |  65 +++
 ...onAssignmentWithInvalidOperands.errors.txt |  36 +-
 ...meticAssignmentLHSCanBeAssigned.errors.txt |  47 ++
 ...icAssignmentWithInvalidOperands.errors.txt |  32 +-
 .../compoundAssignmentLHSIsValue.errors.txt   |   8 +-
 ...tionAssignmentLHSCanBeAssigned1.errors.txt |  47 ++
 ...onAssignmentLHSCannotBeAssigned.errors.txt |  32 +-
 ...onentiationAssignmentLHSIsValue.errors.txt |   8 +-
 .../contextuallyTypedIifeStrict.errors.txt    |  45 ++
 ...thAnyOtherTypeInvalidOperations.errors.txt |  56 +-
 .../deleteOperatorWithAnyOtherType.errors.txt |  29 +-
 .../emitExponentiationOperator4.errors.txt    |  70 +++
 ...onentiationOperatorSyntaxError2.errors.txt |  32 +-
 ...WithNullValueAndInvalidOperands.errors.txt |  48 +-
 ...orWithNullValueAndValidOperands.errors.txt |  47 ++
 ...thOnlyNullValueOrUndefinedValue.errors.txt |  32 +-
 ...ndefinedValueAndInvalidOperands.errors.txt |  48 +-
 ...hUndefinedValueAndValidOperands.errors.txt |  47 ++
 ...gReturnStatementsAndExpressions.errors.txt |   5 +-
 ...thAnyOtherTypeInvalidOperations.errors.txt |  56 +-
 tests/baselines/reference/literals.errors.txt |  16 +-
 ...icalNotOperatorWithAnyOtherType.errors.txt |  29 +-
 .../moduleVariableArrayIndexer.errors.txt     |  11 +
 ...negateOperatorInvalidOperations.errors.txt |  24 +-
 .../nonPrimitiveStrictNull.errors.txt         |  14 +-
 tests/baselines/reference/null.errors.txt     |  28 +
 .../reference/nullKeyword.errors.txt          |   6 +-
 .../operatorAddNullUndefined.errors.txt       |  64 ++-
 .../plusOperatorWithAnyOtherType.errors.txt   |  29 +-
 .../reference/propertyAccess4.errors.txt      |   6 +-
 .../reference/propertyAccess5.errors.txt      |   6 +-
 .../typeofOperatorWithAnyOtherType.errors.txt |  29 +-
 .../voidOperatorWithAnyOtherType.errors.txt   |  29 +-
 .../reference/widenedTypes.errors.txt         |   4 +-
 51 files changed, 2531 insertions(+), 1035 deletions(-)
 create mode 100644 tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
 create mode 100644 tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
 create mode 100644 tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
 create mode 100644 tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
 create mode 100644 tests/baselines/reference/binaryArithmatic1.errors.txt
 create mode 100644 tests/baselines/reference/binaryArithmatic2.errors.txt
 create mode 100644 tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.errors.txt
 create mode 100644 tests/baselines/reference/compoundArithmeticAssignmentLHSCanBeAssigned.errors.txt
 create mode 100644 tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.errors.txt
 create mode 100644 tests/baselines/reference/contextuallyTypedIifeStrict.errors.txt
 create mode 100644 tests/baselines/reference/emitExponentiationOperator4.errors.txt
 create mode 100644 tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.errors.txt
 create mode 100644 tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.errors.txt
 create mode 100644 tests/baselines/reference/moduleVariableArrayIndexer.errors.txt
 create mode 100644 tests/baselines/reference/null.errors.txt

diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
index d18a9a13d8c..5f0d78c59d5 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(11,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(12,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(13,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(14,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(15,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(16,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(19,10): error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(21,10): error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(22,11): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(23,11): error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(11,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(12,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(13,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(14,14): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(15,14): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(16,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(19,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(20,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(21,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(22,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(23,11): error TS2531: Object is possibly 'null'.
 
 
 ==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts (11 errors) ====
@@ -23,37 +23,37 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
     
     // null + boolean/Object
     var r1 = null + a;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r2 = null + b;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r3 = null + c;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r4 = a + null;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+                 ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r5 = b + null;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
+                 ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r6 = null + c;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     
     // other cases
     var r7 = null + d;
-             ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r8 = null + true;
-             ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r9 = null + { a: '' };
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r10 = null + foo();
-              ~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r11 = null + (() => { });
-              ~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
\ No newline at end of file
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
new file mode 100644
index 00000000000..db01a42c8bd
--- /dev/null
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.errors.txt
@@ -0,0 +1,63 @@
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(15,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(16,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(17,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(18,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(19,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(20,14): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(21,14): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(22,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(23,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts(24,20): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts (10 errors) ====
+    // If one operand is the null or undefined value, it is treated as having the type of the other operand.
+    
+    enum E { a, b, c }
+    
+    var a: any;
+    var b: number;
+    var c: E;
+    var d: string;
+    
+    // null + any
+    var r1: any = null + a;
+    var r2: any = a + null;
+    
+    // null + number/enum
+    var r3 = null + b;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4 = null + 1;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r5 = null + c;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r6 = null + E.a;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r7 = null + E['a'];
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r8 = b + null;
+                 ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r9 = 1 + null;
+                 ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r10 = c + null
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r11 = E.a + null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r12 = E['a'] + null;
+                       ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // null + string
+    var r13 = null + d;
+    var r14 = null + '';
+    var r15 = d + null;
+    var r16 = '' + null;
\ No newline at end of file
diff --git a/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.errors.txt b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
index 9e7e4c01ad2..aef66891be0 100644
--- a/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
@@ -1,20 +1,32 @@
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(2,10): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(3,10): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(4,10): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(5,10): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(2,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(2,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(3,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(3,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(4,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(4,22): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(5,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts(5,22): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts (4 errors) ====
+==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts (8 errors) ====
     // bug 819721
     var r1 = null + null;
-             ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r2 = null + undefined;
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r3 = undefined + null;
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                         ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r4 = undefined + undefined;
-             ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
\ No newline at end of file
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                         ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt b/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
index ff7120c145d..478c4fdee3f 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.errors.txt
@@ -8,8 +8,8 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(27,15): error TS2365: Operator '+' cannot be applied to types 'Object' and 'T'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(28,15): error TS2365: Operator '+' cannot be applied to types 'E' and 'T'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(29,15): error TS2365: Operator '+' cannot be applied to types 'void' and 'T'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(32,15): error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(33,15): error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(32,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(33,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(34,15): error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(35,15): error TS2365: Operator '+' cannot be applied to types 'T' and 'U'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts(36,15): error TS2365: Operator '+' cannot be applied to types 'T' and '() => void'.
@@ -69,11 +69,11 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
     
         // other cases
         var r15 = t + null;
-                  ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
         var r16 = t + undefined;
-                  ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
+                      ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         var r17 = t + t;
                   ~~~~~
 !!! error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
index d61f101a544..06e8c67b105 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(11,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(12,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(13,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(14,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(15,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(16,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(19,10): error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(21,10): error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(22,11): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(23,11): error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(11,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(12,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(13,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(14,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(15,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(16,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(19,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(20,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(21,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(22,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(23,11): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts (11 errors) ====
@@ -23,37 +23,37 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
     
     // undefined + boolean/Object
     var r1 = undefined + a;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r2 = undefined + b;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r3 = undefined + c;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r4 = a + undefined;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r5 = b + undefined;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r6 = undefined + c;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // other cases
     var r7 = undefined + d;
-             ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r8 = undefined + true;
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r9 = undefined + { a: '' };
-             ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r10 = undefined + foo();
-              ~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r11 = undefined + (() => { });
-              ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
\ No newline at end of file
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
new file mode 100644
index 00000000000..04c0e2f3266
--- /dev/null
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.errors.txt
@@ -0,0 +1,63 @@
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(15,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(16,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(17,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(18,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(19,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(20,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(21,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(22,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(23,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts(24,20): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts (10 errors) ====
+    // If one operand is the null or undefined value, it is treated as having the type of the other operand.
+    
+    enum E { a, b, c }
+    
+    var a: any;
+    var b: number;
+    var c: E;
+    var d: string;
+    
+    // undefined + any
+    var r1: any = undefined + a;
+    var r2: any = a + undefined;
+    
+    // undefined + number/enum
+    var r3 = undefined + b;
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r4 = undefined + 1;
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r5 = undefined + c;
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r6 = undefined + E.a;
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r7 = undefined + E['a'];
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r8 = b + undefined;
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r9 = 1 + undefined;
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r10 = c + undefined
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r11 = E.a + undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var r12 = E['a'] + undefined;
+                       ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // undefined + string
+    var r13 = undefined + d;
+    var r14 = undefined + '';
+    var r15 = d + undefined;
+    var r16 = '' + undefined;
\ No newline at end of file
diff --git a/tests/baselines/reference/ambientWithStatements.errors.txt b/tests/baselines/reference/ambientWithStatements.errors.txt
index 6fb6aafd864..3e134970a1f 100644
--- a/tests/baselines/reference/ambientWithStatements.errors.txt
+++ b/tests/baselines/reference/ambientWithStatements.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/ambientWithStatements.ts(2,5): error TS1036: Statements are not allowed in ambient contexts.
 tests/cases/compiler/ambientWithStatements.ts(3,5): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/compiler/ambientWithStatements.ts(7,15): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
+tests/cases/compiler/ambientWithStatements.ts(7,15): error TS2531: Object is possibly 'null'.
 tests/cases/compiler/ambientWithStatements.ts(11,5): error TS1108: A 'return' statement can only be used within a function body.
 tests/cases/compiler/ambientWithStatements.ts(25,5): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
 
@@ -18,7 +18,7 @@ tests/cases/compiler/ambientWithStatements.ts(25,5): error TS2410: The 'with' st
         var x;
         for (x in null) { }
                   ~~~~
-!!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
+!!! error TS2531: Object is possibly 'null'.
         if (true) { } else { }
         1;
         L: var y;
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
index c043cda8e68..16a0264a805 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.errors.txt
@@ -1,234 +1,246 @@
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(9,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(9,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(10,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(10,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(11,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(11,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(13,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(13,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(14,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(14,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(15,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(15,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(17,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(17,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(18,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(18,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(19,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(19,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(21,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(21,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(22,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(22,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(23,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(26,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(23,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(26,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(26,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(27,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(27,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(27,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(28,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(28,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(28,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(30,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(30,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(30,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(31,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(31,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(31,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(32,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(32,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(34,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(32,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(34,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(34,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(35,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(35,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(35,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(36,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(36,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(36,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(38,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(38,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(38,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(39,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(39,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(39,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(40,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(40,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(43,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(40,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(43,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(43,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(44,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(44,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(44,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(45,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(45,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(45,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(47,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(47,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(47,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(48,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(48,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(48,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(49,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(49,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(51,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(49,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(51,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(51,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(52,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(52,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(52,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(53,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(53,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(53,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(55,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(55,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(55,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(56,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(56,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(56,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(57,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(57,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(60,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(57,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(60,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(60,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(61,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(61,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(61,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(62,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(62,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(62,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(64,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(64,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(64,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(65,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(65,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(65,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(66,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(66,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(68,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(66,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(68,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(68,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(69,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(69,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(69,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(70,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(70,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(70,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(72,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(72,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(72,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(73,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(73,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(73,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(74,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(74,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(77,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(74,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(77,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(77,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(78,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(78,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(78,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(79,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(79,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(79,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(81,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(81,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(81,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(82,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(82,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(82,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(83,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(83,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(85,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(83,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(85,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(85,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(86,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(86,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(86,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(87,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(87,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(87,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(89,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(89,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(89,20): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(90,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(90,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(90,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(91,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(91,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(94,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(91,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(94,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(94,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(95,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(95,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(95,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(96,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(96,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(96,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(98,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(98,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(98,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(99,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(99,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(99,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(100,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(100,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(102,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(100,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(102,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(102,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(103,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(103,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(103,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(104,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(104,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(104,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(106,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(106,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(106,20): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(107,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(107,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(107,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(108,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(108,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(111,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(108,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(111,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(111,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(112,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(112,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(112,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(113,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(113,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(113,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(115,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(115,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(115,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(116,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(116,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(116,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(117,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(117,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(119,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(117,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(119,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(119,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(120,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(120,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(120,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(121,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(121,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(121,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(123,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(123,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(123,21): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(124,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(124,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(124,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(125,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(125,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(128,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(129,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(125,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(128,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(128,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(129,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(129,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(130,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(130,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(130,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(132,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(132,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(132,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(133,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(133,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(133,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(134,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(134,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(136,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(137,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(134,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(136,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(136,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(137,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(137,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(138,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(138,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(138,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(140,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(140,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(140,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(141,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(141,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(141,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(142,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(142,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(145,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(146,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(142,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(145,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(145,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(146,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(146,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(147,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(147,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(147,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(149,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(149,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(149,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(150,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(150,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(150,16): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(151,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(151,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(153,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(154,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(151,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(153,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(153,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(154,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(154,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(155,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(155,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(155,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(157,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(157,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(157,19): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(158,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(158,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(158,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(159,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(159,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(162,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(163,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(159,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(162,13): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(162,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(163,13): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(163,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(164,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(164,13): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(164,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(166,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(166,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(166,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(167,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(167,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(167,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(168,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(168,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(170,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(171,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(168,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(170,13): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(170,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(171,13): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(171,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(172,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(172,13): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(172,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(174,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(174,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(174,20): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(175,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(175,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(175,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(176,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(176,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts(176,18): error TS2531: Object is possibly 'null'.
 
 
-==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts (228 errors) ====
+==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts (240 errors) ====
     // If one operand is the null or undefined value, it is treated as having the type of the
     // other operand.
     
@@ -239,17 +251,17 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
     // operator *
     var r1a1 = null * a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a2 = null * b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a3 = null * c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -257,31 +269,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1b2 = b * null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1b3 = c * null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r1c1 = null * true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c2 = null * '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c3 = null * {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -289,32 +301,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1d2 = '' * null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1d3 = {} * null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator /
     var r2a1 = null / a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2a2 = null / b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2a3 = null / c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -322,31 +334,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r2b2 = b / null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r2b3 = c / null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r2c1 = null / true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2c2 = null / '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2c3 = null / {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -354,32 +366,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r2d2 = '' / null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r2d3 = {} / null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator %
     var r3a1 = null % a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3a2 = null % b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3a3 = null % c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -387,31 +399,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r3b2 = b % null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r3b3 = c % null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r3c1 = null % true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3c2 = null % '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3c3 = null % {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -419,32 +431,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r3d2 = '' % null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r3d3 = {} % null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator -
     var r4a1 = null - a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4a2 = null - b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4a3 = null - c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -452,31 +464,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r4b2 = b - null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r4b3 = c - null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r4c1 = null - true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4c2 = null - '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4c3 = null - {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -484,32 +496,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r4d2 = '' - null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r4d3 = {} - null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator <<
     var r5a1 = null << a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5a2 = null << b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5a3 = null << c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -517,31 +529,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r5b2 = b << null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r5b3 = c << null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r5c1 = null << true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5c2 = null << '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5c3 = null << {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -549,32 +561,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r5d2 = '' << null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r5d3 = {} << null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator >>
     var r6a1 = null >> a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6a2 = null >> b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6a3 = null >> c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -582,31 +594,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r6b2 = b >> null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r6b3 = c >> null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r6c1 = null >> true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6c2 = null >> '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6c3 = null >> {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -614,32 +626,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r6d2 = '' >> null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r6d3 = {} >> null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator >>>
     var r7a1 = null >>> a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7a2 = null >>> b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7a3 = null >>> c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -647,31 +659,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r7b2 = b >>> null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r7b3 = c >>> null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r7c1 = null >>> true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7c2 = null >>> '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7c3 = null >>> {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                         ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -679,185 +691,209 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                         ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r7d2 = '' >>> null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r7d3 = {} >>> null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator &
     var r8a1 = null & a;
-               ~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8a2 = null & b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8a3 = null & c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r8b1 = a & null;
-               ~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r8b2 = b & null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r8b3 = c & null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r8c1 = null & true;
-               ~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8c2 = null & '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8c3 = null & {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r8d1 = true & null;
-               ~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r8d2 = '' & null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r8d3 = {} & null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator ^
     var r9a1 = null ^ a;
-               ~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9a2 = null ^ b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9a3 = null ^ c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r9b1 = a ^ null;
-               ~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r9b2 = b ^ null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r9b3 = c ^ null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r9c1 = null ^ true;
-               ~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9c2 = null ^ '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9c3 = null ^ {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r9d1 = true ^ null;
-               ~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r9d2 = '' ^ null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r9d3 = {} ^ null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     // operator |
     var r10a1 = null | a;
-                ~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                       ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10a2 = null | b;
                 ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10a3 = null | c;
                 ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r10b1 = a | null;
-                ~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r10b2 = b | null;
                 ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r10b3 = c | null;
                 ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r10c1 = null | true;
-                ~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                       ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10c2 = null | '';
                 ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10c3 = null | {};
                 ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r10d1 = true | null;
-                ~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var r10d2 = '' | null;
                 ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r10d3 = {} | null;
                 ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
new file mode 100644
index 00000000000..426db291224
--- /dev/null
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.errors.txt
@@ -0,0 +1,353 @@
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(13,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(14,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(15,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(16,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(17,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(18,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(19,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(20,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(23,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(24,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(25,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(26,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(27,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(28,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(29,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(30,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(33,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(34,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(35,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(36,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(37,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(38,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(39,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(40,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(43,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(44,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(45,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(46,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(47,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(48,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(49,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(50,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(53,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(54,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(55,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(56,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(57,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(58,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(59,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(60,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(63,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(64,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(65,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(66,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(67,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(68,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(69,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(70,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(73,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(74,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(75,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(76,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(77,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(78,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(79,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(80,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(83,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(84,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(85,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(86,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(87,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(88,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(89,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(90,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(93,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(94,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(95,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(96,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(97,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(98,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(99,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(100,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(103,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(104,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(105,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(106,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(107,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(108,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(109,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts(110,17): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts (80 errors) ====
+    // If one operand is the null or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    enum E {
+        a,
+        b
+    }
+    
+    var a: any;
+    var b: number;
+    
+    // operator *
+    var ra1 = null * a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra2 = null * b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra3 = null * 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra4 = null * E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra5 = a * null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra6 = b * null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra7 = 0 * null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra8 = E.b * null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator /
+    var rb1 = null / a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb2 = null / b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb3 = null / 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb4 = null / E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb5 = a / null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb6 = b / null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb7 = 0 / null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb8 = E.b / null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator %
+    var rc1 = null % a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc2 = null % b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc3 = null % 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc4 = null % E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc5 = a % null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc6 = b % null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc7 = 0 % null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc8 = E.b % null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator -
+    var rd1 = null - a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd2 = null - b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd3 = null - 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd4 = null - E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd5 = a - null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd6 = b - null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd7 = 0 - null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd8 = E.b - null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator <<
+    var re1 = null << a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re2 = null << b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re3 = null << 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re4 = null << E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re5 = a << null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re6 = b << null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re7 = 0 << null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var re8 = E.b << null;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator >>
+    var rf1 = null >> a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf2 = null >> b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf3 = null >> 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf4 = null >> E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf5 = a >> null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf6 = b >> null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf7 = 0 >> null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rf8 = E.b >> null;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator >>>
+    var rg1 = null >>> a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg2 = null >>> b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg3 = null >>> 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg4 = null >>> E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg5 = a >>> null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg6 = b >>> null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg7 = 0 >>> null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rg8 = E.b >>> null;
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator &
+    var rh1 = null & a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh2 = null & b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh3 = null & 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh4 = null & E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh5 = a & null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh6 = b & null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh7 = 0 & null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rh8 = E.b & null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator ^
+    var ri1 = null ^ a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri2 = null ^ b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri3 = null ^ 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri4 = null ^ E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri5 = a ^ null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri6 = b ^ null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri7 = 0 ^ null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ri8 = E.b ^ null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator |
+    var rj1 = null | a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj2 = null | b;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj3 = null | 1;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj4 = null | E.a;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj5 = a | null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj6 = b | null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj7 = 0 | null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rj8 = E.b | null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.errors.txt b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
index d00eee1d4dd..e67db44a780 100644
--- a/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
@@ -1,302 +1,302 @@
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(2,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(2,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(3,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(3,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(4,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(4,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(5,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(5,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(8,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(8,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(9,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(9,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(10,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(10,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(11,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(11,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(14,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(14,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(15,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(15,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(16,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(16,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(17,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(17,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(20,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(20,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(21,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(21,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(22,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(22,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(23,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(23,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(26,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(26,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(27,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(27,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(28,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(28,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(29,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(29,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(32,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(32,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(33,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(33,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(34,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(34,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(35,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(35,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(38,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(38,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(39,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(39,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(40,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(40,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(41,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(41,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(44,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(44,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(45,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(45,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(46,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(46,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(47,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(47,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(50,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(50,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(51,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(51,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(52,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(52,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(53,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(53,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(56,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(56,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(57,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(57,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(58,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(58,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(59,11): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(59,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(2,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(2,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(3,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(3,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(4,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(4,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(5,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(5,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(8,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(8,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(9,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(9,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(10,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(10,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(11,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(11,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(14,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(14,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(15,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(15,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(16,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(16,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(17,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(17,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(20,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(20,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(21,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(21,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(22,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(22,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(23,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(23,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(26,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(26,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(27,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(27,19): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(28,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(28,24): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(29,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(29,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(32,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(32,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(33,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(33,19): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(34,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(34,24): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(35,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(35,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(38,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(38,20): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(39,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(39,20): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(40,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(40,25): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(41,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(41,25): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(44,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(44,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(45,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(45,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(46,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(46,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(47,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(47,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(50,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(50,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(51,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(51,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(52,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(52,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(53,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(53,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(56,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(56,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(57,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(57,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(58,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(58,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(59,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts(59,23): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts (80 errors) ====
     // operator *
     var ra1 = null * null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var ra2 = null * undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var ra3 = undefined * null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var ra4 = undefined * undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator /
     var rb1 = null / null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rb2 = null / undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rb3 = undefined / null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rb4 = undefined / undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator %
     var rc1 = null % null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rc2 = null % undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rc3 = undefined % null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rc4 = undefined % undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator -
     var rd1 = null - null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rd2 = null - undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rd3 = undefined - null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rd4 = undefined - undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator <<
     var re1 = null << null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var re2 = null << undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var re3 = undefined << null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var re4 = undefined << undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator >>
     var rf1 = null >> null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rf2 = null >> undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rf3 = undefined >> null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rf4 = undefined >> undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator >>>
     var rg1 = null >>> null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rg2 = null >>> undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rg3 = undefined >>> null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rg4 = undefined >>> undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator &
     var rh1 = null & null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rh2 = null & undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rh3 = undefined & null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rh4 = undefined & undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator ^
     var ri1 = null ^ null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var ri2 = null ^ undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var ri3 = undefined ^ null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var ri4 = undefined ^ undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator |
     var rj1 = null | null;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rj2 = null | undefined;
               ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var rj3 = undefined | null;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var rj4 = undefined | undefined;
               ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
index 9ee53c2f15c..8a9d014f2c2 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -1,234 +1,246 @@
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(9,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(9,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(10,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(10,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(11,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(11,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(13,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(13,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(14,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(14,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(15,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(15,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(17,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(17,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(18,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(18,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(19,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(19,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(21,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(21,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(22,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(22,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(23,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(26,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(23,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(26,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(26,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(27,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(27,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(27,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(28,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(28,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(28,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(30,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(30,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(30,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(31,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(31,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(31,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(32,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(32,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(34,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(32,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(34,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(34,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(35,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(35,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(35,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(36,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(36,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(36,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(38,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(38,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(38,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(39,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(39,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(39,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(40,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(40,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(43,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(40,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(43,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(43,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(44,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(44,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(44,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(45,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(45,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(45,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(47,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(47,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(47,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(48,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(48,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(48,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(49,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(49,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(51,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(49,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(51,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(51,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(52,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(52,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(52,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(53,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(53,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(53,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(55,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(55,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(55,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(56,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(56,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(56,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(57,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(57,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(60,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(57,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(60,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(60,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(61,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(61,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(61,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(62,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(62,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(62,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(64,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(64,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(64,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(65,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(65,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(65,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(66,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(66,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(68,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(66,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(68,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(68,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(69,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(69,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(69,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(70,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(70,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(70,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(72,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(72,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(72,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(73,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(73,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(73,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(74,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(74,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(77,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(74,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(77,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(77,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(78,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(78,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(78,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(79,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(79,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(79,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(81,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(81,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(81,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(82,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(82,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(82,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(83,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(83,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(85,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(83,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(85,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(85,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(86,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(86,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(86,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(87,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(87,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(87,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(89,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(89,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(89,20): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(90,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(90,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(90,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(91,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(91,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(94,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(91,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(94,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(94,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(95,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(95,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(95,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(96,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(96,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(96,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(98,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(98,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(98,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(99,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(99,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(99,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(100,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(100,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(102,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(100,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(102,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(102,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(103,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(103,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(103,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(104,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(104,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(104,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(106,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(106,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(106,20): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(107,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(107,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(107,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(108,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(108,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(111,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(108,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(111,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(111,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(112,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(112,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(112,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(113,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(113,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(113,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(115,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(115,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(115,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(116,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(116,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(116,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(117,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(117,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(119,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(117,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(119,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(119,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(120,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(120,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(120,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(121,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(121,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(121,26): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(123,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(123,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(123,21): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(124,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(124,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(124,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(125,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(125,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(128,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(129,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(125,19): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(128,12): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(128,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(129,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(129,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(130,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(130,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(130,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(132,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(132,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(132,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(133,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(133,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(133,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(134,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(134,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(136,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(137,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(134,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(136,12): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(136,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(137,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(137,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(138,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(138,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(138,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(140,12): error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(140,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(140,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(141,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(141,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(141,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(142,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(142,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(145,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(146,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(142,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(145,12): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(145,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(146,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(146,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(147,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(147,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(147,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(149,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(149,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(149,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(150,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(150,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(150,16): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(151,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(151,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(153,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(154,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(151,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(153,12): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(153,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(154,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(154,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(155,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(155,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(155,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(157,12): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(157,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(157,19): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(158,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(158,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(158,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(159,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(159,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(162,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(163,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(159,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(162,13): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(162,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(163,13): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(163,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(164,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(164,13): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(164,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(166,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(166,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(166,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(167,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(167,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(167,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(168,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(168,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(170,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(171,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(168,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(170,13): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(170,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(171,13): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(171,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(172,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(172,13): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(172,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(174,13): error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(174,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(174,20): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(175,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(175,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(175,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(176,13): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(176,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts(176,18): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts (228 errors) ====
+==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts (240 errors) ====
     // If one operand is the undefined or undefined value, it is treated as having the type of the
     // other operand.
     
@@ -239,17 +251,17 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
     // operator *
     var r1a1 = undefined * a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a2 = undefined * b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a3 = undefined * c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -257,31 +269,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1b2 = b * undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1b3 = c * undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r1c1 = undefined * true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c2 = undefined * '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c3 = undefined * {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -289,32 +301,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1d2 = '' * undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1d3 = {} * undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator /
     var r2a1 = undefined / a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2a2 = undefined / b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2a3 = undefined / c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -322,31 +334,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r2b2 = b / undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r2b3 = c / undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r2c1 = undefined / true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2c2 = undefined / '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r2c3 = undefined / {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -354,32 +366,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r2d2 = '' / undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r2d3 = {} / undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator %
     var r3a1 = undefined % a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3a2 = undefined % b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3a3 = undefined % c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -387,31 +399,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r3b2 = b % undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r3b3 = c % undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r3c1 = undefined % true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3c2 = undefined % '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r3c3 = undefined % {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -419,32 +431,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r3d2 = '' % undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r3d3 = {} % undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator -
     var r4a1 = undefined - a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4a2 = undefined - b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4a3 = undefined - c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -452,31 +464,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r4b2 = b - undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r4b3 = c - undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r4c1 = undefined - true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4c2 = undefined - '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r4c3 = undefined - {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -484,32 +496,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r4d2 = '' - undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r4d3 = {} - undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator <<
     var r5a1 = undefined << a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5a2 = undefined << b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5a3 = undefined << c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -517,31 +529,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r5b2 = b << undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r5b3 = c << undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r5c1 = undefined << true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5c2 = undefined << '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r5c3 = undefined << {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -549,32 +561,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r5d2 = '' << undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r5d3 = {} << undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator >>
     var r6a1 = undefined >> a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6a2 = undefined >> b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6a3 = undefined >> c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -582,31 +594,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r6b2 = b >> undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r6b3 = c >> undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r6c1 = undefined >> true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6c2 = undefined >> '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r6c3 = undefined >> {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -614,32 +626,32 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r6d2 = '' >> undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r6d3 = {} >> undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator >>>
     var r7a1 = undefined >>> a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7a2 = undefined >>> b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7a3 = undefined >>> c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -647,31 +659,31 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r7b2 = b >>> undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r7b3 = c >>> undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r7c1 = undefined >>> true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7c2 = undefined >>> '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r7c3 = undefined >>> {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                              ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -679,185 +691,209 @@ tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeti
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                         ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r7d2 = '' >>> undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r7d3 = {} >>> undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                       ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator &
     var r8a1 = undefined & a;
-               ~~~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8a2 = undefined & b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8a3 = undefined & c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r8b1 = a & undefined;
-               ~~~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r8b2 = b & undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r8b3 = c & undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r8c1 = undefined & true;
-               ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8c2 = undefined & '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r8c3 = undefined & {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r8d1 = true & undefined;
-               ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '&' operator is not allowed for boolean types. Consider using '&&' instead.
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                      ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r8d2 = '' & undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r8d3 = {} & undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator ^
     var r9a1 = undefined ^ a;
-               ~~~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9a2 = undefined ^ b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9a3 = undefined ^ c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r9b1 = a ^ undefined;
-               ~~~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r9b2 = b ^ undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r9b3 = c ^ undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                    ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r9c1 = undefined ^ true;
-               ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9c2 = undefined ^ '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r9c3 = undefined ^ {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                            ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r9d1 = true ^ undefined;
-               ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                      ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r9d2 = '' ^ undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r9d3 = {} ^ undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // operator |
     var r10a1 = undefined | a;
-                ~~~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                            ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10a2 = undefined | b;
                 ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10a3 = undefined | c;
                 ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r10b1 = a | undefined;
-                ~~~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r10b2 = b | undefined;
                 ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r10b3 = c | undefined;
                 ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r10c1 = undefined | true;
-                ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                            ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10c2 = undefined | '';
                 ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r10c3 = undefined | {};
                 ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
     var r10d1 = true | undefined;
-                ~~~~~~~~~~~~~~~~
-!!! error TS2447: The '|' operator is not allowed for boolean types. Consider using '||' instead.
+                ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var r10d2 = '' | undefined;
                 ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r10d3 = {} | undefined;
                 ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
new file mode 100644
index 00000000000..246b642603c
--- /dev/null
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.errors.txt
@@ -0,0 +1,353 @@
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(13,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(14,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(15,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(16,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(17,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(18,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(19,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(20,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(23,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(24,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(25,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(26,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(27,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(28,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(29,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(30,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(33,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(34,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(35,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(36,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(37,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(38,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(39,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(40,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(43,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(44,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(45,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(46,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(47,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(48,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(49,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(50,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(53,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(54,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(55,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(56,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(57,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(58,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(59,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(60,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(63,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(64,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(65,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(66,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(67,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(68,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(69,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(70,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(73,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(74,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(75,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(76,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(77,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(78,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(79,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(80,19): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(83,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(84,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(85,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(86,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(87,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(88,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(89,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(90,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(93,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(94,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(95,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(96,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(97,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(98,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(99,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(100,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(103,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(104,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(105,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(106,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(107,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(108,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(109,15): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts(110,17): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts (80 errors) ====
+    // If one operand is the undefined or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    enum E {
+        a,
+        b
+    }
+    
+    var a: any;
+    var b: number;
+    
+    // operator *
+    var ra1 = undefined * a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra2 = undefined * b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra3 = undefined * 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra4 = undefined * E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra5 = a * undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra6 = b * undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra7 = 0 * undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ra8 = E.b * undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator /
+    var rb1 = undefined / a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb2 = undefined / b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb3 = undefined / 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb4 = undefined / E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb5 = a / undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb6 = b / undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb7 = 0 / undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rb8 = E.b / undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator %
+    var rc1 = undefined % a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc2 = undefined % b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc3 = undefined % 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc4 = undefined % E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc5 = a % undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc6 = b % undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc7 = 0 % undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rc8 = E.b % undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator -
+    var rd1 = undefined - a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd2 = undefined - b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd3 = undefined - 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd4 = undefined - E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd5 = a - undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd6 = b - undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd7 = 0 - undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rd8 = E.b - undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator <<
+    var re1 = undefined << a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re2 = undefined << b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re3 = undefined << 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re4 = undefined << E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re5 = a << undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re6 = b << undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re7 = 0 << undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var re8 = E.b << undefined;
+                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator >>
+    var rf1 = undefined >> a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf2 = undefined >> b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf3 = undefined >> 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf4 = undefined >> E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf5 = a >> undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf6 = b >> undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf7 = 0 >> undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rf8 = E.b >> undefined;
+                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator >>>
+    var rg1 = undefined >>> a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg2 = undefined >>> b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg3 = undefined >>> 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg4 = undefined >>> E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg5 = a >>> undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg6 = b >>> undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg7 = 0 >>> undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rg8 = E.b >>> undefined;
+                      ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator &
+    var rh1 = undefined & a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh2 = undefined & b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh3 = undefined & 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh4 = undefined & E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh5 = a & undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh6 = b & undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh7 = 0 & undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rh8 = E.b & undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator ^
+    var ri1 = undefined ^ a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri2 = undefined ^ b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri3 = undefined ^ 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri4 = undefined ^ E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri5 = a ^ undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri6 = b ^ undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri7 = 0 ^ undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var ri8 = E.b ^ undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator |
+    var rj1 = undefined | a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj2 = undefined | b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj3 = undefined | 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj4 = undefined | E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj5 = a | undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj6 = b | undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj7 = 0 | undefined;
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rj8 = E.b | undefined;
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/binaryArithmatic1.errors.txt b/tests/baselines/reference/binaryArithmatic1.errors.txt
new file mode 100644
index 00000000000..51c0b649890
--- /dev/null
+++ b/tests/baselines/reference/binaryArithmatic1.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/compiler/binaryArithmatic1.ts(1,13): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/compiler/binaryArithmatic1.ts (1 errors) ====
+    var v = 4 | null;
+                ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/binaryArithmatic2.errors.txt b/tests/baselines/reference/binaryArithmatic2.errors.txt
new file mode 100644
index 00000000000..28f379c30e2
--- /dev/null
+++ b/tests/baselines/reference/binaryArithmatic2.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/compiler/binaryArithmatic2.ts(1,13): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/compiler/binaryArithmatic2.ts (1 errors) ====
+    var v = 4 | undefined;
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/binaryArithmatic3.errors.txt b/tests/baselines/reference/binaryArithmatic3.errors.txt
index 6dffe5e150c..1457407a7b8 100644
--- a/tests/baselines/reference/binaryArithmatic3.errors.txt
+++ b/tests/baselines/reference/binaryArithmatic3.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/binaryArithmatic3.ts(1,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/binaryArithmatic3.ts(1,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/binaryArithmatic3.ts(1,9): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/binaryArithmatic3.ts(1,21): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/compiler/binaryArithmatic3.ts (2 errors) ====
     var v = undefined | undefined;
             ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                         ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/binaryArithmatic4.errors.txt b/tests/baselines/reference/binaryArithmatic4.errors.txt
index f72c23073ca..fe7523e0884 100644
--- a/tests/baselines/reference/binaryArithmatic4.errors.txt
+++ b/tests/baselines/reference/binaryArithmatic4.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/binaryArithmatic4.ts(1,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/binaryArithmatic4.ts(1,16): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/binaryArithmatic4.ts(1,9): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/binaryArithmatic4.ts(1,16): error TS2531: Object is possibly 'null'.
 
 
 ==== tests/cases/compiler/binaryArithmatic4.ts (2 errors) ====
     var v = null | null;
             ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                    ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
index 66d4cbb628e..262ac042c68 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
@@ -1,9 +1,12 @@
-tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,26): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,26): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,33): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,26): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,38): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (3 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (6 errors) ====
     
     // ~ operator on any type
     
@@ -51,14 +54,20 @@ tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNot
     var ResultIsNumber14 = ~A.foo();
     var ResultIsNumber15 = ~(ANY + ANY1);
     var ResultIsNumber16 = ~(null + undefined);
-                             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber17 = ~(null + null);
-                             ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber18 = ~(undefined + undefined);
-                             ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                         ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // multiple ~ operators
     var ResultIsNumber19 = ~~ANY;
diff --git a/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.errors.txt b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.errors.txt
new file mode 100644
index 00000000000..08d8fd0c6d3
--- /dev/null
+++ b/tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.errors.txt
@@ -0,0 +1,65 @@
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentLHSCanBeAssigned.ts(32,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentLHSCanBeAssigned.ts(33,7): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentLHSCanBeAssigned.ts(39,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentLHSCanBeAssigned.ts(40,7): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentLHSCanBeAssigned.ts (4 errors) ====
+    enum E { a, b }
+    
+    var a: any;
+    var b: void;
+    
+    var x1: any;
+    x1 += a;
+    x1 += b;
+    x1 += true;
+    x1 += 0;
+    x1 += '';
+    x1 += E.a;
+    x1 += {};
+    x1 += null;
+    x1 += undefined;
+    
+    var x2: string;
+    x2 += a;
+    x2 += b;
+    x2 += true;
+    x2 += 0;
+    x2 += '';
+    x2 += E.a;
+    x2 += {};
+    x2 += null;
+    x2 += undefined;
+    
+    var x3: number;
+    x3 += a;
+    x3 += 0;
+    x3 += E.a;
+    x3 += null;
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x3 += undefined;
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x4: E;
+    x4 += a;
+    x4 += 0;
+    x4 += E.a;
+    x4 += null;
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x4 += undefined;
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x5: boolean;
+    x5 += a;
+    
+    var x6: {};
+    x6 += a;
+    x6 += '';
+    
+    var x7: void;
+    x7 += a;
\ No newline at end of file
diff --git a/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt b/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt
index cadc5c945d1..1812065f149 100644
--- a/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt
@@ -3,22 +3,22 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmen
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(8,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and '0'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(9,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'E.a'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(10,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and '{}'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(11,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(12,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(11,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(12,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(15,1): error TS2365: Operator '+=' cannot be applied to types '{}' and 'void'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(16,1): error TS2365: Operator '+=' cannot be applied to types '{}' and 'true'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(17,1): error TS2365: Operator '+=' cannot be applied to types '{}' and '0'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(18,1): error TS2365: Operator '+=' cannot be applied to types '{}' and 'E.a'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(19,1): error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(20,1): error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(21,1): error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(20,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(21,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(24,1): error TS2365: Operator '+=' cannot be applied to types 'void' and 'void'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(25,1): error TS2365: Operator '+=' cannot be applied to types 'void' and 'true'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(26,1): error TS2365: Operator '+=' cannot be applied to types 'void' and '0'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(27,1): error TS2365: Operator '+=' cannot be applied to types 'void' and 'E.a'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(28,1): error TS2365: Operator '+=' cannot be applied to types 'void' and '{}'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(29,1): error TS2365: Operator '+=' cannot be applied to types 'void' and 'void'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(30,1): error TS2365: Operator '+=' cannot be applied to types 'void' and 'void'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(29,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(30,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(33,1): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(34,1): error TS2365: Operator '+=' cannot be applied to types 'number' and 'true'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(35,1): error TS2365: Operator '+=' cannot be applied to types 'number' and '{}'.
@@ -49,11 +49,11 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmen
     ~~~~~~~~
 !!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and '{}'.
     x1 += null;
-    ~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
     x1 += undefined;
-    ~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x2: {};
     x2 += a;
@@ -72,11 +72,11 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmen
     ~~~~~~~~
 !!! error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
     x2 += null;
-    ~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
     x2 += undefined;
-    ~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types '{}' and '{}'.
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x3: void;
     x3 += a;
@@ -95,11 +95,11 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmen
     ~~~~~~~~
 !!! error TS2365: Operator '+=' cannot be applied to types 'void' and '{}'.
     x3 += null;
-    ~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types 'void' and 'void'.
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
     x3 += undefined;
-    ~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types 'void' and 'void'.
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x4: number;
     x4 += a;
diff --git a/tests/baselines/reference/compoundArithmeticAssignmentLHSCanBeAssigned.errors.txt b/tests/baselines/reference/compoundArithmeticAssignmentLHSCanBeAssigned.errors.txt
new file mode 100644
index 00000000000..f438045a45f
--- /dev/null
+++ b/tests/baselines/reference/compoundArithmeticAssignmentLHSCanBeAssigned.errors.txt
@@ -0,0 +1,47 @@
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(11,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(12,7): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(18,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(19,7): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(25,7): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts(26,7): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentLHSCanBeAssigned.ts (6 errors) ====
+    enum E { a, b, c }
+    
+    var a: any;
+    var b: number;
+    var c: E;
+    
+    var x1: any;
+    x1 *= a;
+    x1 *= b;
+    x1 *= c;
+    x1 *= null;
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x1 *= undefined;
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x2: number;
+    x2 *= a;
+    x2 *= b;
+    x2 *= c;
+    x2 *= null;
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x2 *= undefined;
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x3: E;
+    x3 *= a;
+    x3 *= b;
+    x3 *= c;
+    x3 *= null;
+          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x3 *= undefined;
+          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.errors.txt b/tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.errors.txt
index 9367285ef93..7429445b422 100644
--- a/tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.errors.txt
@@ -10,9 +10,9 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(13,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(14,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(14,7): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(15,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(15,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(15,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(18,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(19,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -25,9 +25,9 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(24,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(24,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(25,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(25,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(25,7): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(26,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(26,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(26,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(29,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(30,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -40,9 +40,9 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(35,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(35,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(36,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(36,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(36,7): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(37,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(37,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(41,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -55,9 +55,9 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(46,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(47,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(47,7): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(48,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(48,7): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(51,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(52,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignmentWithInvalidOperands.ts(53,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -108,12 +108,12 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x1 *= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x2: string;
     x2 *= a;
@@ -149,12 +149,12 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x2 *= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x3: {};
     x3 *= a;
@@ -190,12 +190,12 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x3 *= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x4: void;
     x4 *= a;
@@ -231,12 +231,12 @@ tests/cases/conformance/expressions/assignmentOperator/compoundArithmeticAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x4 *= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x5: number;
     x5 *= b;
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
index bc6bb41b27f..8948467c590 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
+++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
@@ -17,6 +17,7 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
@@ -55,6 +56,7 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,2): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,2): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
@@ -74,7 +76,7 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
 
 
-==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (74 errors) ====
+==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (76 errors) ====
     
     // expected error for all the LHS of compound assignments (arithmetic and addition)
     var value: any;
@@ -158,6 +160,8 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
     null *= value;
     ~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     null += value;
     ~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
@@ -295,6 +299,8 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
     (null) *= value;
     ~~~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+    ~~~~~~
+!!! error TS2531: Object is possibly 'null'.
     (null) += value;
     ~~~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.errors.txt
new file mode 100644
index 00000000000..26f23028dfa
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.errors.txt
@@ -0,0 +1,47 @@
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(11,8): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(12,8): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(18,8): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(19,8): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(25,8): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts(26,8): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts (6 errors) ====
+    enum E { a, b, c }
+    
+    var a: any;
+    var b: number;
+    var c: E;
+    
+    var x1: any;
+    x1 **= a;
+    x1 **= b;
+    x1 **= c;
+    x1 **= null;
+           ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x1 **= undefined;
+           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x2: number;
+    x2 **= a;
+    x2 **= b;
+    x2 **= c;
+    x2 **= null;
+           ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x2 **= undefined;
+           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    var x3: E;
+    x3 **= a;
+    x3 **= b;
+    x3 **= c;
+    x3 **= null;
+           ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    x3 **= undefined;
+           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt
index 8d152712808..6d48d968638 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt
@@ -10,9 +10,9 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(13,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(13,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(14,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(14,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(14,8): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(15,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(15,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(15,8): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(18,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(19,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -25,9 +25,9 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(24,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(24,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(25,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(25,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(25,8): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(26,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(26,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(26,8): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(29,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(30,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -40,9 +40,9 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(35,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(35,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(36,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(36,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(36,8): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(37,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(37,8): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(41,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -55,9 +55,9 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(46,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(47,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(47,8): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(48,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(48,8): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(51,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(52,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(53,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -108,12 +108,12 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x1 **= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x2: string;
     x2 **= a;
@@ -149,12 +149,12 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x2 **= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x3: {};
     x3 **= a;
@@ -190,12 +190,12 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x3 **= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x4: void;
     x4 **= a;
@@ -231,12 +231,12 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     x4 **= undefined;
     ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var x5: number;
     x5 **= b;
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
index 22eeb18ac4a..51b69f81620 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
@@ -8,6 +8,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(30,1): error TS2539: Cannot assign to 'E' because it is not a variable.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(32,1): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(35,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(35,1): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(36,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(38,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
@@ -28,6 +29,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(75,2): error TS2539: Cannot assign to 'E' because it is not a variable.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(76,2): error TS2539: Cannot assign to 'foo' because it is not a variable.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(77,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(77,1): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(78,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(79,1): error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(80,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -38,7 +40,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(85,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 
 
-==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (38 errors) ====
+==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (40 errors) ====
     // expected error for all the LHS of compound assignments (arithmetic and addition)
     var value: any;
     
@@ -94,6 +96,8 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     null **= value;
     ~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     true **= value;
     ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
@@ -176,6 +180,8 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     (null) **= value;
     ~~~~~~
 !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access.
+    ~~~~~~
+!!! error TS2531: Object is possibly 'null'.
     (true) **= value;
     ~~~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
diff --git a/tests/baselines/reference/contextuallyTypedIifeStrict.errors.txt b/tests/baselines/reference/contextuallyTypedIifeStrict.errors.txt
new file mode 100644
index 00000000000..220204fc536
--- /dev/null
+++ b/tests/baselines/reference/contextuallyTypedIifeStrict.errors.txt
@@ -0,0 +1,45 @@
+tests/cases/conformance/expressions/functions/contextuallyTypedIifeStrict.ts(14,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/functions/contextuallyTypedIifeStrict.ts(15,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/functions/contextuallyTypedIifeStrict.ts(16,17): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/functions/contextuallyTypedIifeStrict.ts (3 errors) ====
+    // arrow
+    (jake => { })("build");
+    // function expression
+    (function (cats) { })("lol");
+    // Lots of Irritating Superfluous Parentheses
+    (function (x) { } ("!"));
+    ((((function (y) { }))))("-");
+    // multiple arguments
+    ((a, b, c) => { })("foo", 101, false);
+    // default parameters
+    ((m = 10) => m + 1)(12);
+    ((n = 10) => n + 1)();
+    // optional parameters
+    ((j?) => j + 1)(12);
+             ~
+!!! error TS2532: Object is possibly 'undefined'.
+    ((k?) => k + 1)();
+             ~
+!!! error TS2532: Object is possibly 'undefined'.
+    ((l, o?) => l + o)(12); // o should be any
+                    ~
+!!! error TS2532: Object is possibly 'undefined'.
+    // rest parameters
+    ((...numbers) => numbers.every(n => n > 0))(5,6,7);
+    ((...mixed) => mixed.every(n => !!n))(5,'oops','oh no');
+    ((...noNumbers) => noNumbers.some(n => n > 0))();
+    ((first, ...rest) => first ? [] : rest.map(n => n > 0))(8,9,10);
+    // destructuring parameters (with defaults too!)
+    (({ q }) => q)({ q : 13 });
+    (({ p = 14 }) => p)({ p : 15 });
+    (({ r = 17 } = { r: 18 }) => r)({r : 19});
+    (({ u = 22 } = { u: 23 }) => u)();
+    // contextually typed parameters.
+    let twelve = (f => f(12))(i => i);
+    let eleven = (o => o.a(11))({ a: function(n) { return n; } });
+    // missing arguments
+    (function(x, undefined) { return x; })(42);
+    ((x, y, z) => 42)();
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index e42b6ff67b4..e5456d6f0bd 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -17,21 +17,27 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(46,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(47,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,34): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,27): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,34): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,27): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,39): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(51,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(52,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(54,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(55,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,25): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,25): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,32): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,25): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,25): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,32): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,25): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,25): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,37): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(59,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(60,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(63,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
@@ -50,7 +56,7 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(72,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (50 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (56 errors) ====
     // -- operator on any type
     var ANY1: any;
     var ANY2: any[] = ["", ""];
@@ -137,18 +143,24 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
     var ResultIsNumber19 = --(null + undefined);
                              ~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber20 = --(null + null);
                              ~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber21 = --(undefined + undefined);
                              ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber22 = --obj1.x;
                              ~~~~~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
@@ -165,18 +177,24 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
     var ResultIsNumber26 = (null + undefined)--;
                            ~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                            ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber27 = (null + null)--;
                            ~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                            ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber28 = (undefined + undefined)--;
                            ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                            ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                        ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber29 = obj1.x--;
                            ~~~~~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
diff --git a/tests/baselines/reference/deleteOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/deleteOperatorWithAnyOtherType.errors.txt
index 69153fc235c..819f1c39050 100644
--- a/tests/baselines/reference/deleteOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/deleteOperatorWithAnyOtherType.errors.txt
@@ -9,12 +9,15 @@ tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperator
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(42,32): error TS2703: The operand of a delete operator must be a property reference
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(43,32): error TS2703: The operand of a delete operator must be a property reference
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(44,33): error TS2703: The operand of a delete operator must be a property reference
-tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(45,33): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(45,33): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(45,33): error TS2703: The operand of a delete operator must be a property reference
-tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(46,33): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(45,40): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(46,33): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(46,33): error TS2703: The operand of a delete operator must be a property reference
-tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(47,33): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(46,40): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(47,33): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(47,33): error TS2703: The operand of a delete operator must be a property reference
+tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(47,45): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(50,32): error TS2703: The operand of a delete operator must be a property reference
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(50,39): error TS2703: The operand of a delete operator must be a property reference
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(51,32): error TS2703: The operand of a delete operator must be a property reference
@@ -25,7 +28,7 @@ tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperator
 tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts(57,8): error TS2703: The operand of a delete operator must be a property reference
 
 
-==== tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts (25 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithAnyOtherType.ts (28 errors) ====
     // delete  operator on any type
     
     var ANY: any;
@@ -93,20 +96,26 @@ tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperator
                                     ~~~~~~~~~~
 !!! error TS2703: The operand of a delete operator must be a property reference
     var ResultIsBoolean17 = delete (null + undefined);
-                                    ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
                                     ~~~~~~~~~~~~~~~~
 !!! error TS2703: The operand of a delete operator must be a property reference
+                                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsBoolean18 = delete (null + null);
-                                    ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
                                     ~~~~~~~~~~~
 !!! error TS2703: The operand of a delete operator must be a property reference
+                                           ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsBoolean19 = delete (undefined + undefined);
-                                    ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                     ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2703: The operand of a delete operator must be a property reference
+                                                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // multiple delete  operators
     var ResultIsBoolean20 = delete delete ANY;
diff --git a/tests/baselines/reference/emitExponentiationOperator4.errors.txt b/tests/baselines/reference/emitExponentiationOperator4.errors.txt
new file mode 100644
index 00000000000..e8f46874ad8
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator4.errors.txt
@@ -0,0 +1,70 @@
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(14,1): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(15,1): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(16,1): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(17,1): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(18,1): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(21,6): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(22,6): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(23,6): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(24,6): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts(25,6): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts (10 errors) ====
+    var temp: any;
+    
+    (<number>temp) ** 3;
+    (<number>--temp) ** 3;
+    (<number>++temp) ** 3;
+    (<number>temp--) ** 3;
+    (<number>temp++) ** 3;
+    
+    1 ** (<number>--temp) ** 3;
+    1 ** (<number>++temp) ** 3;
+    1 ** (<number>temp--) ** 3;
+    1 ** (<number>temp++) ** 3;
+    
+    (void --temp) ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    (void temp--) ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    (void 3) ** 4;
+    ~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    (void temp++) ** 4;
+    ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    (void temp--) ** 4;
+    ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    
+    1 ** (void --temp) ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    1 ** (void temp--) ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    1 ** (void 3) ** 4;
+         ~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    1 ** (void temp++) ** 4;
+         ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    1 ** (void temp--) ** 4;
+         ~~~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    (~ --temp) ** 3;
+    (~ temp--) ** 3;
+    (~ 3) ** 4;
+    (~ temp++) ** 4;
+    (~ temp--) ** 4;
+    
+    1 ** (~ --temp) ** 3;
+    1 ** (~ temp--) ** 3;
+    1 ** (~ 3) ** 4;
+    1 ** (~ temp++) ** 4;
+    1 ** (~ temp--) ** 4;
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt
index 6ac93ecf27a..1075c505794 100644
--- a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt
+++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt
@@ -42,15 +42,25 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(29,1): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(29,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(30,1): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(30,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(35,6): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(35,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(36,6): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(36,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(40,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(41,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
@@ -89,7 +99,7 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(68,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
 
 
-==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts (89 errors) ====
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts (99 errors) ====
     
     // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
     var temp: any;
@@ -207,34 +217,54 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxE
     
     void --temp ** 3;
     ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     void temp-- ** 3;
     ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     void 3 ** 4;
     ~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    ~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     void temp++ ** 4;
     ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     void temp-- ** 4;
     ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     
     1 ** void --temp ** 3;
          ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+         ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     1 ** void temp-- ** 3;
          ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+         ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     1 ** void 3 ** 4;
          ~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+         ~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     1 ** void temp++ ** 4;
          ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+         ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     1 ** void temp-- ** 4 ;
          ~~~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+         ~~~~~~~~~~~
 !!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
     
     ~ --temp ** 3;
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt
index 99535985628..2d0b76f28cc 100644
--- a/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt
@@ -1,27 +1,27 @@
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(9,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(9,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(10,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(10,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(11,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(11,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(13,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(13,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(14,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(14,17): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(15,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(15,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(17,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(17,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(18,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(18,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(19,12): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(19,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(21,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(21,20): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(22,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(22,18): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(23,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(23,18): error TS2531: Object is possibly 'null'.
 
 
 ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts (24 errors) ====
@@ -35,17 +35,17 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNul
     // operator **
     var r1a1 = null ** a;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a2 = null ** b;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a3 = null ** c;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -53,31 +53,31 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNul
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1b2 = b ** null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1b3 = c ** null;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     
     var r1c1 = null ** true;
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c2 = null ** '';
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c3 = null ** {};
                ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                        ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -85,14 +85,14 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNul
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1d2 = '' ** null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r1d3 = {} ** null;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.errors.txt
new file mode 100644
index 00000000000..c8a462c0f54
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.errors.txt
@@ -0,0 +1,47 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(13,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(14,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(15,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(16,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(17,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(18,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(19,15): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts(20,17): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts (8 errors) ====
+    // If one operand is the null or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    enum E {
+        a,
+        b
+    }
+    
+    var a: any;
+    var b: number;
+    
+    // operator **
+    var r1 = null ** a;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2 = null ** b;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3 = null ** 1;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4 = null ** E.a;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r5 = a ** null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r6 = b ** null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r7 = 0 ** null;
+                  ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r8 = E.b ** null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
index 86f4930e77c..20b004625ca 100644
--- a/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
+++ b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
@@ -1,33 +1,33 @@
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,18): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,23): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts (8 errors) ====
     // operator **
     var r1 = null ** null;
              ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r2 = null ** undefined;
              ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r3 = undefined ** null;
              ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var r4 = undefined ** undefined;
              ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                           ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt
index f456e0f554f..ce14298d02d 100644
--- a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -1,27 +1,27 @@
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(9,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(9,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(10,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(10,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(11,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(11,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(13,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(13,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(14,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(14,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(15,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(15,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(17,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(17,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(18,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(18,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(19,12): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(19,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(21,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(21,20): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(22,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(22,18): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(23,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(23,18): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts (24 errors) ====
@@ -35,17 +35,17 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUnd
     // operator **
     var r1a1 = undefined ** a;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a2 = undefined ** b;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1a3 = undefined ** c;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -53,31 +53,31 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUnd
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1b2 = b ** undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1b3 = c ** undefined;
                ~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                     ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var r1c1 = undefined ** true;
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c2 = undefined ** '';
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var r1c3 = undefined ** {};
                ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                             ~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     
@@ -85,14 +85,14 @@ tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUnd
                ~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                        ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1d2 = '' ** undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var r1d3 = {} ** undefined;
                ~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
                      ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.errors.txt
new file mode 100644
index 00000000000..ce9843a9612
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.errors.txt
@@ -0,0 +1,47 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(13,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(14,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(15,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(16,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(17,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(18,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(19,16): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts(20,18): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts (8 errors) ====
+    // If one operand is the undefined or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    enum E {
+        a,
+        b
+    }
+    
+    var a: any;
+    var b: number;
+    
+    // operator *
+    var rk1 = undefined ** a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk2 = undefined ** b;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk3 = undefined ** 1;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk4 = undefined ** E.a;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk5 = a ** undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk6 = b ** undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk7 = 0 ** undefined;
+                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    var rk8 = E.b ** undefined;
+                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
index 1ccc296b75b..e0c552141b2 100644
--- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
+++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
@@ -1,10 +1,11 @@
 tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(101,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(106,16): error TS2378: A 'get' accessor must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(128,15): error TS2532: Object is possibly 'undefined'.
 tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(129,5): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (4 errors) ====
+==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ====
     
     
     function f1(): string {
@@ -139,6 +140,8 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(129,5): e
             // if no return statements are present but we are a get accessor.
             throw null;
             throw undefined.
+                  ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         }
         ~
 !!! error TS1003: Identifier expected.
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index 0a303d12bf3..bf980bfd153 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -17,21 +17,27 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(46,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(47,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(48,34): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,27): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(49,34): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,27): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(50,39): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(51,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(52,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(54,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(55,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,25): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,25): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(56,32): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,25): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,25): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(57,32): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,25): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,25): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(58,37): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(59,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(60,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(63,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
@@ -45,7 +51,7 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (45 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (51 errors) ====
     // ++ operator on any type
     var ANY1: any;
     var ANY2: any[] = [1, 2];
@@ -132,18 +138,24 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
     var ResultIsNumber19 = ++(null + undefined);
                              ~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber20 = ++(null + null);
                              ~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber21 = ++(undefined + undefined);
                              ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                              ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber22 = ++obj1.x;
                              ~~~~~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
@@ -160,18 +172,24 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
     var ResultIsNumber26 = (null + undefined)++;
                            ~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                            ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber27 = (null + null)++;
                            ~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                            ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber28 = (undefined + undefined)++;
                            ~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
-                            ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                            ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                        ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber29 = obj1.x++;
                            ~~~~~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
diff --git a/tests/baselines/reference/literals.errors.txt b/tests/baselines/reference/literals.errors.txt
index 6fa1d7d3abd..ae058e0b530 100644
--- a/tests/baselines/reference/literals.errors.txt
+++ b/tests/baselines/reference/literals.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/expressions/literals/literals.ts(9,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/literals/literals.ts(9,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/literals/literals.ts(10,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/literals/literals.ts(10,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/literals/literals.ts(9,10): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/literals/literals.ts(9,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/literals/literals.ts(10,9): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/literals/literals.ts(10,21): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/literals/literals.ts(20,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'.
 tests/cases/conformance/expressions/literals/literals.ts(25,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'.
 
@@ -17,14 +17,14 @@ tests/cases/conformance/expressions/literals/literals.ts(25,9): error TS1085: Oc
     
     var nu = null / null;
              ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                     ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var u = undefined / undefined;
             ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                         ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     var b: boolean;
     var b = true;
diff --git a/tests/baselines/reference/logicalNotOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/logicalNotOperatorWithAnyOtherType.errors.txt
index 02b4bf16fd2..0cb9869ca4c 100644
--- a/tests/baselines/reference/logicalNotOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/logicalNotOperatorWithAnyOtherType.errors.txt
@@ -1,10 +1,13 @@
-tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(45,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(46,27): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(47,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(45,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(45,34): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(46,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(46,34): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(47,27): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(47,39): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts(57,1): error TS2695: Left side of comma operator is unused and has no side effects.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts (4 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts (7 errors) ====
     // ! operator on any type
     
     var ANY: any;
@@ -50,14 +53,20 @@ tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNot
     var ResultIsBoolean15 = !A.foo();
     var ResultIsBoolean16 = !(ANY + ANY1);
     var ResultIsBoolean17 = !(null + undefined);
-                              ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsBoolean18 = !(null + null);
-                              ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsBoolean19 = !(undefined + undefined);
-                              ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // multiple ! operators
     var ResultIsBoolean20 = !!ANY;
diff --git a/tests/baselines/reference/moduleVariableArrayIndexer.errors.txt b/tests/baselines/reference/moduleVariableArrayIndexer.errors.txt
new file mode 100644
index 00000000000..f0c070375f6
--- /dev/null
+++ b/tests/baselines/reference/moduleVariableArrayIndexer.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/compiler/moduleVariableArrayIndexer.ts(3,13): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/compiler/moduleVariableArrayIndexer.ts (1 errors) ====
+    module Bar {
+        export var a = 1;
+        var t = undefined[a][a]; // CG: var t = undefined[Bar.a][a];
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/negateOperatorInvalidOperations.errors.txt b/tests/baselines/reference/negateOperatorInvalidOperations.errors.txt
index 3bc5689d170..e0f818ba9c1 100644
--- a/tests/baselines/reference/negateOperatorInvalidOperations.errors.txt
+++ b/tests/baselines/reference/negateOperatorInvalidOperations.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(4,15): error TS1109: Expression expected.
 tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(4,25): error TS1005: '=' expected.
 tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(4,26): error TS1109: Expression expected.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(7,17): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(7,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(8,17): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(8,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(9,17): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(9,29): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(7,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(7,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(8,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(8,24): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(9,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(9,29): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorInvalidOperations.ts(12,14): error TS1109: Expression expected.
 
 
@@ -25,19 +25,19 @@ tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperator
     // invalid expressions
     var NUMBER2 = -(null - undefined);
                     ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                            ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     var NUMBER3 = -(null - null);
                     ~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
                            ~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2531: Object is possibly 'null'.
     var NUMBER4 = -(undefined - undefined);
                     ~~~~~~~~~
-!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
                                 ~~~~~~~~~
-!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+!!! error TS2532: Object is possibly 'undefined'.
     
     // miss operand
     var NUMBER =-;
diff --git a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt
index de6fbfcf698..473011aaa7f 100644
--- a/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt
+++ b/tests/baselines/reference/nonPrimitiveStrictNull.errors.txt
@@ -12,21 +12,17 @@ tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(22,5): erro
   Type 'null' is not assignable to type 'object'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(27,5): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(29,5): error TS2532: Object is possibly 'undefined'.
-tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(29,7): error TS2339: Property 'toString' does not exist on type 'never'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(33,5): error TS2533: Object is possibly 'null' or 'undefined'.
-tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(33,7): error TS2339: Property 'toString' does not exist on type 'never'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(39,5): error TS2531: Object is possibly 'null'.
-tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(39,7): error TS2339: Property 'toString' does not exist on type 'never'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(41,5): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(45,5): error TS2532: Object is possibly 'undefined'.
-tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(45,7): error TS2339: Property 'toString' does not exist on type 'never'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(47,5): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(52,14): error TS2344: Type 'number' does not satisfy the constraint 'object'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(53,14): error TS2344: Type 'null' does not satisfy the constraint 'object'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): error TS2344: Type 'undefined' does not satisfy the constraint 'object'.
 
 
-==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts (22 errors) ====
+==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts (18 errors) ====
     
     var a: object
     declare var b: object | null
@@ -80,16 +76,12 @@ tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): err
         d.toString(); // error, undefined
         ~
 !!! error TS2532: Object is possibly 'undefined'.
-          ~~~~~~~~
-!!! error TS2339: Property 'toString' does not exist on type 'never'.
     }
     
     if (d == null) {
         d.toString(); // error, undefined | null
         ~
 !!! error TS2533: Object is possibly 'null' or 'undefined'.
-          ~~~~~~~~
-!!! error TS2339: Property 'toString' does not exist on type 'never'.
     } else {
         d.toString(); // object
     }
@@ -98,8 +90,6 @@ tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): err
         d.toString(); // error, null
         ~
 !!! error TS2531: Object is possibly 'null'.
-          ~~~~~~~~
-!!! error TS2339: Property 'toString' does not exist on type 'never'.
     } else {
         d.toString(); // error, object | undefined
         ~
@@ -110,8 +100,6 @@ tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts(54,14): err
         d.toString(); // error, undefined
         ~
 !!! error TS2532: Object is possibly 'undefined'.
-          ~~~~~~~~
-!!! error TS2339: Property 'toString' does not exist on type 'never'.
     } else {
         d.toString(); // error, object | null
         ~
diff --git a/tests/baselines/reference/null.errors.txt b/tests/baselines/reference/null.errors.txt
new file mode 100644
index 00000000000..f957507438c
--- /dev/null
+++ b/tests/baselines/reference/null.errors.txt
@@ -0,0 +1,28 @@
+tests/cases/compiler/null.ts(4,9): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/compiler/null.ts (1 errors) ====
+    
+    var x=null; 
+    var y=3+x;  
+    var z=3+null; 
+            ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    class C {
+    }
+    function f() {
+        return null;
+        return new C();
+    }
+    function g() {
+        return null;
+        return 3;
+    }
+    interface I {
+        x:any;
+        y:number;
+    }
+    var w:I={x:null,y:3};
+    
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/nullKeyword.errors.txt b/tests/baselines/reference/nullKeyword.errors.txt
index a140fce0b0f..b815b61b676 100644
--- a/tests/baselines/reference/nullKeyword.errors.txt
+++ b/tests/baselines/reference/nullKeyword.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/nullKeyword.ts(1,6): error TS2339: Property 'foo' does not exist on type 'null'.
+tests/cases/compiler/nullKeyword.ts(1,1): error TS2531: Object is possibly 'null'.
 
 
 ==== tests/cases/compiler/nullKeyword.ts (1 errors) ====
     null.foo;
-         ~~~
-!!! error TS2339: Property 'foo' does not exist on type 'null'.
\ No newline at end of file
+    ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/operatorAddNullUndefined.errors.txt b/tests/baselines/reference/operatorAddNullUndefined.errors.txt
index 269ee0a5166..871ef3fc98f 100644
--- a/tests/baselines/reference/operatorAddNullUndefined.errors.txt
+++ b/tests/baselines/reference/operatorAddNullUndefined.errors.txt
@@ -1,32 +1,68 @@
-tests/cases/compiler/operatorAddNullUndefined.ts(2,10): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/compiler/operatorAddNullUndefined.ts(3,10): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/compiler/operatorAddNullUndefined.ts(4,10): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/compiler/operatorAddNullUndefined.ts(5,10): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(2,10): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(2,17): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(3,10): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(3,17): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(4,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(4,22): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(5,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(5,22): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(6,14): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(7,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(8,10): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(9,10): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(14,11): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(15,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/operatorAddNullUndefined.ts(16,17): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/operatorAddNullUndefined.ts(17,17): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/compiler/operatorAddNullUndefined.ts (4 errors) ====
+==== tests/cases/compiler/operatorAddNullUndefined.ts (16 errors) ====
     enum E { x }
     var x1 = null + null;
-             ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var x2 = null + undefined;
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var x3 = undefined + null;
-             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                         ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var x4 = undefined + undefined;
-             ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                         ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var x5 = 1 + null;
+                 ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var x6 = 1 + undefined;
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var x7 = null + 1;
+             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var x8 = undefined + 1;
+             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var x9 = "test" + null;
     var x10 = "test" + undefined;
     var x11 = null + "test";
     var x12 = undefined + "test";
     var x13 = null + E.x
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var x14 = undefined + E.x
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var x15 = E.x + null
-    var x16 = E.x + undefined
\ No newline at end of file
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var x16 = E.x + undefined
+                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
index 6c0f113b17b..c316cf92e6d 100644
--- a/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
@@ -1,10 +1,13 @@
-tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(46,26): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(47,26): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(48,26): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(46,26): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(46,33): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(47,33): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(48,26): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(48,38): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(54,1): error TS2695: Left side of comma operator is unused and has no side effects.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts (4 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts (7 errors) ====
     // + operator on any type
     
     var ANY: any;
@@ -51,14 +54,20 @@ tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWith
     var ResultIsNumber15 = +A.foo();
     var ResultIsNumber16 = +(ANY + ANY1);
     var ResultIsNumber17 = +(null + undefined);
-                             ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber18 = +(null + null);
-                             ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber19 = +(undefined + undefined);
-                             ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                             ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                         ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // miss assignment operators
     +ANY;
diff --git a/tests/baselines/reference/propertyAccess4.errors.txt b/tests/baselines/reference/propertyAccess4.errors.txt
index cdc772ba528..fc491d8c7a9 100644
--- a/tests/baselines/reference/propertyAccess4.errors.txt
+++ b/tests/baselines/reference/propertyAccess4.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/propertyAccess4.ts(1,6): error TS2339: Property 'toBAZ' does not exist on type 'null'.
+tests/cases/compiler/propertyAccess4.ts(1,1): error TS2531: Object is possibly 'null'.
 
 
 ==== tests/cases/compiler/propertyAccess4.ts (1 errors) ====
     null.toBAZ();
-         ~~~~~
-!!! error TS2339: Property 'toBAZ' does not exist on type 'null'.
\ No newline at end of file
+    ~~~~
+!!! error TS2531: Object is possibly 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/propertyAccess5.errors.txt b/tests/baselines/reference/propertyAccess5.errors.txt
index 81c05c5342b..4f7e7f4bcd6 100644
--- a/tests/baselines/reference/propertyAccess5.errors.txt
+++ b/tests/baselines/reference/propertyAccess5.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/propertyAccess5.ts(1,11): error TS2339: Property 'toBAZ' does not exist on type 'undefined'.
+tests/cases/compiler/propertyAccess5.ts(1,1): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/compiler/propertyAccess5.ts (1 errors) ====
     undefined.toBAZ();
-              ~~~~~
-!!! error TS2339: Property 'toBAZ' does not exist on type 'undefined'.
\ No newline at end of file
+    ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
index 94bca545609..3680b1be60f 100644
--- a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
@@ -1,6 +1,9 @@
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(46,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(47,32): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(48,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(46,32): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(46,39): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(47,32): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(47,39): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(48,32): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(48,44): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(58,1): error TS2695: Left side of comma operator is unused and has no side effects.
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(68,1): error TS7028: Unused label.
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(69,1): error TS7028: Unused label.
@@ -11,7 +14,7 @@ tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperator
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(74,1): error TS7028: Unused label.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (11 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (14 errors) ====
     // typeof  operator on any type
     
     var ANY: any;
@@ -58,14 +61,20 @@ tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperator
     var ResultIsString15 = typeof A.foo();
     var ResultIsString16 = typeof (ANY + ANY1);
     var ResultIsString17 = typeof (null + undefined);
-                                   ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsString18 = typeof (null + null);
-                                   ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                          ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsString19 = typeof (undefined + undefined);
-                                   ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                                   ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                               ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // multiple typeof  operators
     var ResultIsString20 = typeof typeof ANY;
diff --git a/tests/baselines/reference/voidOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/voidOperatorWithAnyOtherType.errors.txt
index 8796f316303..5867a7ad6f5 100644
--- a/tests/baselines/reference/voidOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/voidOperatorWithAnyOtherType.errors.txt
@@ -1,9 +1,12 @@
-tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(46,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
-tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(47,27): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
-tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(48,27): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(46,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(46,34): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(47,27): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(47,34): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(48,27): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts(48,39): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts (3 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithAnyOtherType.ts (6 errors) ====
     // void  operator on any type
     
     var ANY: any;
@@ -50,14 +53,20 @@ tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWith
     var ResultIsAny15 = void A.foo();
     var ResultIsAny16 = void (ANY + ANY1);
     var ResultIsAny17 = void (null + undefined);
-                              ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsAny18 = void (null + null);
-                              ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
+                              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsAny19 = void (undefined + undefined);
-                              ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+                              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     
     // multiple void  operators
     var ResultIsAny20 = void void ANY;
diff --git a/tests/baselines/reference/widenedTypes.errors.txt b/tests/baselines/reference/widenedTypes.errors.txt
index 5ea097acf2e..1fd338e6410 100644
--- a/tests/baselines/reference/widenedTypes.errors.txt
+++ b/tests/baselines/reference/widenedTypes.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/widenedTypes.ts(2,1): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
 tests/cases/compiler/widenedTypes.ts(6,7): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
-tests/cases/compiler/widenedTypes.ts(8,15): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
+tests/cases/compiler/widenedTypes.ts(8,15): error TS2531: Object is possibly 'null'.
 tests/cases/compiler/widenedTypes.ts(10,14): error TS2695: Left side of comma operator is unused and has no side effects.
 tests/cases/compiler/widenedTypes.ts(11,1): error TS2322: Type '""' is not assignable to type 'number'.
 tests/cases/compiler/widenedTypes.ts(18,1): error TS2322: Type '""' is not assignable to type 'number'.
@@ -25,7 +25,7 @@ tests/cases/compiler/widenedTypes.ts(24,5): error TS2322: Type '{ x: number; y:
     
     for (var a in null) { }
                   ~~~~
-!!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
+!!! error TS2531: Object is possibly 'null'.
     
     var t = [3, (3, null)];
                  ~

From 8ce193c30295300c7b09d50a73fae770003f41c4 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 15:54:39 -0800
Subject: [PATCH 049/159] Improved undefined/null handling for relational
 operators

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index cb48b2176f9..434dd46d0eb 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14585,7 +14585,6 @@ namespace ts {
             }
             // NOTE: do not raise error if right is unknown as related error was already reported
             if (!(isTypeAny(rightType) ||
-                  rightType.flags & TypeFlags.Nullable ||
                   getSignaturesOfType(rightType, SignatureKind.Call).length ||
                   getSignaturesOfType(rightType, SignatureKind.Construct).length ||
                   isTypeSubtypeOf(rightType, globalFunctionType))) {
@@ -14598,6 +14597,8 @@ namespace ts {
             if (leftType === silentNeverType || rightType === silentNeverType) {
                 return silentNeverType;
             }
+            leftType = checkNonNullType(leftType, left);
+            rightType = checkNonNullType(rightType, right);
             // TypeScript 1.0 spec (April 2014): 4.15.5
             // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
             // and the right operand to be of type Any, an object type, or a type parameter type.
@@ -14952,8 +14953,8 @@ namespace ts {
                 case SyntaxKind.LessThanEqualsToken:
                 case SyntaxKind.GreaterThanEqualsToken:
                     if (checkForDisallowedESSymbolOperand(operator)) {
-                        leftType = getBaseTypeOfLiteralType(leftType);
-                        rightType = getBaseTypeOfLiteralType(rightType);
+                        leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left));
+                        rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right));
                         if (!isTypeComparableTo(leftType, rightType) && !isTypeComparableTo(rightType, leftType)) {
                             reportOperatorError();
                         }

From 6dcaac621419d023d6c34b94b2ed8c901e0147dc Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 15:54:50 -0800
Subject: [PATCH 050/159] Accept new baselines

---
 ...yncFunctionDeclaration10_es2017.errors.txt |   5 +-
 .../asyncFunctionDeclaration10_es5.errors.txt |   5 +-
 .../asyncFunctionDeclaration10_es6.errors.txt |   5 +-
 ...syncFunctionDeclaration5_es2017.errors.txt |   5 +-
 .../asyncFunctionDeclaration5_es5.errors.txt  |   5 +-
 .../asyncFunctionDeclaration5_es6.errors.txt  |   5 +-
 ...ratorWithIdenticalPrimitiveType.errors.txt | 130 +++++++
 ...sonOperatorWithOneOperandIsNull.errors.txt | 360 ++++++++++++++++++
 .../reference/equalityStrictNulls.errors.txt  |  24 +-
 .../inOperatorWithInvalidOperands.errors.txt  |  16 +-
 .../reference/widenedTypes.errors.txt         |   9 +-
 11 files changed, 543 insertions(+), 26 deletions(-)
 create mode 100644 tests/baselines/reference/comparisonOperatorWithIdenticalPrimitiveType.errors.txt
 create mode 100644 tests/baselines/reference/comparisonOperatorWithOneOperandIsNull.errors.txt

diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt
index d5da3432264..33cd913a2eb 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt
@@ -4,10 +4,11 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclarati
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,33): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,38): error TS1005: ';' expected.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,39): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,49): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,53): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts (7 errors) ====
+==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts (8 errors) ====
     async function foo(a = await => await): Promise<void> {
                        ~~~~~~~~~
 !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
@@ -21,6 +22,8 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclarati
 !!! error TS1005: ';' expected.
                                           ~
 !!! error TS1128: Declaration or statement expected.
+                                                    ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                                         ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt
index dc814e9c887..b974eacd882 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt
@@ -4,10 +4,11 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,33): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,38): error TS1005: ';' expected.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,39): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,49): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,53): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts (7 errors) ====
+==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts (8 errors) ====
     async function foo(a = await => await): Promise<void> {
                        ~~~~~~~~~
 !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
@@ -21,6 +22,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
 !!! error TS1005: ';' expected.
                                           ~
 !!! error TS1128: Declaration or statement expected.
+                                                    ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                                         ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt
index 15ceb3e60c7..b752ec94a45 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt
@@ -4,10 +4,11 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,38): error TS1005: ';' expected.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,39): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,49): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (7 errors) ====
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (8 errors) ====
     async function foo(a = await => await): Promise<void> {
                        ~~~~~~~~~
 !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
@@ -21,6 +22,8 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
 !!! error TS1005: ';' expected.
                                           ~
 !!! error TS1128: Declaration or statement expected.
+                                                    ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                                         ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es2017.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.errors.txt
index ad8c0280206..1fc74dfa0a2 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration5_es2017.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.errors.txt
@@ -2,10 +2,11 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclarati
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts(1,20): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts(1,25): error TS1005: ';' expected.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts(1,26): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts(1,36): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts(1,40): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts (5 errors) ====
+==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts (6 errors) ====
     async function foo(await): Promise<void> {
                        ~~~~~
 !!! error TS1138: Parameter declaration expected.
@@ -15,6 +16,8 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclarati
 !!! error TS1005: ';' expected.
                              ~
 !!! error TS1128: Declaration or statement expected.
+                                       ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                            ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration5_es5.errors.txt
index 3060c2c836b..48299773218 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration5_es5.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es5.errors.txt
@@ -2,10 +2,11 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts(1,20): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts(1,25): error TS1005: ';' expected.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts(1,26): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts(1,36): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts(1,40): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts (5 errors) ====
+==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts (6 errors) ====
     async function foo(await): Promise<void> {
                        ~~~~~
 !!! error TS1138: Parameter declaration expected.
@@ -15,6 +16,8 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5
 !!! error TS1005: ';' expected.
                              ~
 !!! error TS1128: Declaration or statement expected.
+                                       ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                            ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt
index a6944e0c6e6..2e907d13400 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt
@@ -2,10 +2,11 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,20): error TS2304: Cannot find name 'await'.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,25): error TS1005: ';' expected.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,26): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,36): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,40): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts (5 errors) ====
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts (6 errors) ====
     async function foo(await): Promise<void> {
                        ~~~~~
 !!! error TS1138: Parameter declaration expected.
@@ -15,6 +16,8 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5
 !!! error TS1005: ';' expected.
                              ~
 !!! error TS1128: Declaration or statement expected.
+                                       ~~~~
+!!! error TS2532: Object is possibly 'undefined'.
                                            ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/comparisonOperatorWithIdenticalPrimitiveType.errors.txt b/tests/baselines/reference/comparisonOperatorWithIdenticalPrimitiveType.errors.txt
new file mode 100644
index 00000000000..ad41a280aad
--- /dev/null
+++ b/tests/baselines/reference/comparisonOperatorWithIdenticalPrimitiveType.errors.txt
@@ -0,0 +1,130 @@
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(15,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(15,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(16,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(16,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(24,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(24,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(25,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(25,23): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(33,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(33,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(34,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(34,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(42,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(42,19): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(43,11): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts(43,24): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalPrimitiveType.ts (16 errors) ====
+    enum E { a, b, c }
+    
+    var a: number;
+    var b: boolean;
+    var c: string;
+    var d: void;
+    var e: E;
+    
+    // operator <
+    var ra1 = a < a;
+    var ra2 = b < b;
+    var ra3 = c < c;
+    var ra4 = d < d;
+    var ra5 = e < e;
+    var ra6 = null < null;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var ra7 = undefined < undefined;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator >
+    var rb1 = a > a;
+    var rb2 = b > b;
+    var rb3 = c > c;
+    var rb4 = d > d;
+    var rb5 = e > e;
+    var rb6 = null > null;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rb7 = undefined > undefined;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                          ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator <=
+    var rc1 = a <= a;
+    var rc2 = b <= b;
+    var rc3 = c <= c;
+    var rc4 = d <= d;
+    var rc5 = e <= e;
+    var rc6 = null <= null;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rc7 = undefined <= undefined;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator >=
+    var rd1 = a >= a;
+    var rd2 = b >= b;
+    var rd3 = c >= c;
+    var rd4 = d >= d;
+    var rd5 = e >= e;
+    var rd6 = null >= null;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
+                      ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var rd7 = undefined >= undefined;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+    
+    // operator ==
+    var re1 = a == a;
+    var re2 = b == b;
+    var re3 = c == c;
+    var re4 = d == d;
+    var re5 = e == e;
+    var re6 = null == null;
+    var re7 = undefined == undefined;
+    
+    // operator !=
+    var rf1 = a != a;
+    var rf2 = b != b;
+    var rf3 = c != c;
+    var rf4 = d != d;
+    var rf5 = e != e;
+    var rf6 = null != null;
+    var rf7 = undefined != undefined;
+    
+    // operator ===
+    var rg1 = a === a;
+    var rg2 = b === b;
+    var rg3 = c === c;
+    var rg4 = d === d;
+    var rg5 = e === e;
+    var rg6 = null === null;
+    var rg7 = undefined === undefined;
+    
+    // operator !==
+    var rh1 = a !== a;
+    var rh2 = b !== b;
+    var rh3 = c !== c;
+    var rh4 = d !== d;
+    var rh5 = e !== e;
+    var rh6 = null !== null;
+    var rh7 = undefined !== undefined;
\ No newline at end of file
diff --git a/tests/baselines/reference/comparisonOperatorWithOneOperandIsNull.errors.txt b/tests/baselines/reference/comparisonOperatorWithOneOperandIsNull.errors.txt
new file mode 100644
index 00000000000..c74ab997a59
--- /dev/null
+++ b/tests/baselines/reference/comparisonOperatorWithOneOperandIsNull.errors.txt
@@ -0,0 +1,360 @@
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(4,22): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(5,22): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(6,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(7,23): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(13,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(14,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(15,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(16,18): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(32,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(33,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(34,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(35,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(36,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(37,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(38,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(40,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(41,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(42,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(43,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(44,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(45,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(46,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(49,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(50,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(51,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(52,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(53,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(54,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(55,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(57,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(58,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(59,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(60,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(61,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(62,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(63,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(66,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(67,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(68,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(69,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(70,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(71,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(72,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(74,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(75,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(76,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(77,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(78,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(79,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(80,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(83,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(84,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(85,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(86,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(87,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(88,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(89,12): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(91,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(92,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(93,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(94,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(95,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(96,17): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts(97,17): error TS2531: Object is possibly 'null'.
+
+
+==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithOneOperandIsNull.ts (64 errors) ====
+    enum E { a, b, c }
+    
+    function foo<T>(t: T) {
+        var foo_r1 = t < null;
+                         ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r2 = t > null;
+                         ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r3 = t <= null;
+                          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r4 = t >= null;
+                          ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r5 = t == null;
+        var foo_r6 = t != null;
+        var foo_r7 = t === null;
+        var foo_r8 = t !== null;
+    
+        var foo_r1 = null < t;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r2 = null > t;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r3 = null <= t;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r4 = null >= t;
+                     ~~~~
+!!! error TS2531: Object is possibly 'null'.
+        var foo_r5 = null == t;
+        var foo_r6 = null != t;
+        var foo_r7 = null === t;
+        var foo_r8 = null !== t;
+    }
+    
+    var a: boolean;
+    var b: number;
+    var c: string;
+    var d: void;
+    var e: E;
+    var f: {};
+    var g: string[];
+    
+    // operator <
+    var r1a1 = null < a;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a2 = null < b;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a3 = null < c;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a4 = null < d;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a5 = null < e;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a6 = null < f;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1a7 = null < g;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    var r1b1 = a < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b2 = b < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b3 = c < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b4 = d < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b5 = e < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b6 = f < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r1b7 = g < null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator >
+    var r2a1 = null > a;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a2 = null > b;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a3 = null > c;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a4 = null > d;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a5 = null > e;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a6 = null > f;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2a7 = null > g;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    var r2b1 = a > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b2 = b > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b3 = c > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b4 = d > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b5 = e > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b6 = f > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r2b7 = g > null;
+                   ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator <=
+    var r3a1 = null <= a;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a2 = null <= b;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a3 = null <= c;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a4 = null <= d;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a5 = null <= e;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a6 = null <= f;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3a7 = null <= g;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    var r3b1 = a <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b2 = b <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b3 = c <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b4 = d <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b5 = e <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b6 = f <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r3b7 = g <= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator >=
+    var r4a1 = null >= a;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a2 = null >= b;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a3 = null >= c;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a4 = null >= d;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a5 = null >= e;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a6 = null >= f;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4a7 = null >= g;
+               ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    var r4b1 = a >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b2 = b >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b3 = c >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b4 = d >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b5 = e >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b6 = f >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    var r4b7 = g >= null;
+                    ~~~~
+!!! error TS2531: Object is possibly 'null'.
+    
+    // operator ==
+    var r5a1 = null == a;
+    var r5a2 = null == b;
+    var r5a3 = null == c;
+    var r5a4 = null == d;
+    var r5a5 = null == e;
+    var r5a6 = null == f;
+    var r5a7 = null == g;
+    
+    var r5b1 = a == null;
+    var r5b2 = b == null;
+    var r5b3 = c == null;
+    var r5b4 = d == null;
+    var r5b5 = e == null;
+    var r5b6 = f == null;
+    var r5b7 = g == null;
+    
+    // operator !=
+    var r6a1 = null != a;
+    var r6a2 = null != b;
+    var r6a3 = null != c;
+    var r6a4 = null != d;
+    var r6a5 = null != e;
+    var r6a6 = null != f;
+    var r6a7 = null != g;
+    
+    var r6b1 = a != null;
+    var r6b2 = b != null;
+    var r6b3 = c != null;
+    var r6b4 = d != null;
+    var r6b5 = e != null;
+    var r6b6 = f != null;
+    var r6b7 = g != null;
+    
+    // operator ===
+    var r7a1 = null === a;
+    var r7a2 = null === b;
+    var r7a3 = null === c;
+    var r7a4 = null === d;
+    var r7a5 = null === e;
+    var r7a6 = null === f;
+    var r7a7 = null === g;
+    
+    var r7b1 = a === null;
+    var r7b2 = b === null;
+    var r7b3 = c === null;
+    var r7b4 = d === null;
+    var r7b5 = e === null;
+    var r7b6 = f === null;
+    var r7b7 = g === null;
+    
+    // operator !==
+    var r8a1 = null !== a;
+    var r8a2 = null !== b;
+    var r8a3 = null !== c;
+    var r8a4 = null !== d;
+    var r8a5 = null !== e;
+    var r8a6 = null !== f;
+    var r8a7 = null !== g;
+    
+    var r8b1 = a !== null;
+    var r8b2 = b !== null;
+    var r8b3 = c !== null;
+    var r8b4 = d !== null;
+    var r8b5 = e !== null;
+    var r8b6 = f !== null;
+    var r8b7 = g !== null;
\ No newline at end of file
diff --git a/tests/baselines/reference/equalityStrictNulls.errors.txt b/tests/baselines/reference/equalityStrictNulls.errors.txt
index e0793542b84..16772d8eeab 100644
--- a/tests/baselines/reference/equalityStrictNulls.errors.txt
+++ b/tests/baselines/reference/equalityStrictNulls.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(60,9): error TS2365: Operator '>' cannot be applied to types 'number' and 'undefined'.
-tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(62,9): error TS2365: Operator '<' cannot be applied to types 'number' and 'undefined'.
-tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(64,9): error TS2365: Operator '>=' cannot be applied to types 'number' and 'undefined'.
-tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(66,9): error TS2365: Operator '<=' cannot be applied to types 'number' and 'undefined'.
+tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(60,13): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(62,13): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(64,14): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts(66,14): error TS2532: Object is possibly 'undefined'.
 
 
 ==== tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.ts (4 errors) ====
@@ -65,20 +65,20 @@ tests/cases/conformance/types/typeRelationships/comparable/equalityStrictNulls.t
     
     function f4(x: number) {
         if (x > undefined) {
-            ~~~~~~~~~~~~~
-!!! error TS2365: Operator '>' cannot be applied to types 'number' and 'undefined'.
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         }
         if (x < undefined) {
-            ~~~~~~~~~~~~~
-!!! error TS2365: Operator '<' cannot be applied to types 'number' and 'undefined'.
+                ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         }
         if (x >= undefined) {
-            ~~~~~~~~~~~~~~
-!!! error TS2365: Operator '>=' cannot be applied to types 'number' and 'undefined'.
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         }
         if (x <= undefined) {
-            ~~~~~~~~~~~~~~
-!!! error TS2365: Operator '<=' cannot be applied to types 'number' and 'undefined'.
+                 ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
         }
     }
     function f5(x: string) {
diff --git a/tests/baselines/reference/inOperatorWithInvalidOperands.errors.txt b/tests/baselines/reference/inOperatorWithInvalidOperands.errors.txt
index 5aeae5f160e..7615008d89c 100644
--- a/tests/baselines/reference/inOperatorWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/inOperatorWithInvalidOperands.errors.txt
@@ -1,6 +1,8 @@
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(12,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(13,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(14,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
+tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(16,11): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(17,11): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(19,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(20,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(30,16): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
@@ -11,13 +13,13 @@ tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInv
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(35,16): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(36,16): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(37,16): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
-tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(38,16): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
-tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(39,17): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
+tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(38,16): error TS2531: Object is possibly 'null'.
+tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(39,17): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(43,11): error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
 tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts(43,17): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
 
 
-==== tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts (17 errors) ====
+==== tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInvalidOperands.ts (19 errors) ====
     enum E { a }
     
     var x: any;
@@ -40,7 +42,11 @@ tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInv
 !!! error TS2360: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.
     var ra4 = a4 in x;
     var ra5 = null in x;
+              ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ra6 = undefined in x;
+              ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ra7 = E.a in x;
     var ra8 = false in x;
               ~~~~~
@@ -83,10 +89,10 @@ tests/cases/conformance/expressions/binaryOperators/inOperator/inOperatorWithInv
 !!! error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
     var rb9 = x in null;
                    ~~~~
-!!! error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
+!!! error TS2531: Object is possibly 'null'.
     var rb10 = x in undefined;
                     ~~~~~~~~~
-!!! error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
+!!! error TS2532: Object is possibly 'undefined'.
     
     
     // both operands are invalid
diff --git a/tests/baselines/reference/widenedTypes.errors.txt b/tests/baselines/reference/widenedTypes.errors.txt
index 1fd338e6410..f0e3ec33f50 100644
--- a/tests/baselines/reference/widenedTypes.errors.txt
+++ b/tests/baselines/reference/widenedTypes.errors.txt
@@ -1,5 +1,6 @@
 tests/cases/compiler/widenedTypes.ts(2,1): error TS2358: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.
-tests/cases/compiler/widenedTypes.ts(6,7): error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
+tests/cases/compiler/widenedTypes.ts(5,1): error TS2531: Object is possibly 'null'.
+tests/cases/compiler/widenedTypes.ts(6,7): error TS2531: Object is possibly 'null'.
 tests/cases/compiler/widenedTypes.ts(8,15): error TS2531: Object is possibly 'null'.
 tests/cases/compiler/widenedTypes.ts(10,14): error TS2695: Left side of comma operator is unused and has no side effects.
 tests/cases/compiler/widenedTypes.ts(11,1): error TS2322: Type '""' is not assignable to type 'number'.
@@ -11,7 +12,7 @@ tests/cases/compiler/widenedTypes.ts(24,5): error TS2322: Type '{ x: number; y:
     Type 'number' is not assignable to type 'string'.
 
 
-==== tests/cases/compiler/widenedTypes.ts (8 errors) ====
+==== tests/cases/compiler/widenedTypes.ts (9 errors) ====
     
     null instanceof (() => { });
     ~~~~
@@ -19,9 +20,11 @@ tests/cases/compiler/widenedTypes.ts(24,5): error TS2322: Type '{ x: number; y:
     ({}) instanceof null; // Ok because null is a subtype of function
     
     null in {};
+    ~~~~
+!!! error TS2531: Object is possibly 'null'.
     "" in null;
           ~~~~
-!!! error TS2361: The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter
+!!! error TS2531: Object is possibly 'null'.
     
     for (var a in null) { }
                   ~~~~

From 894ba853a080ae33a7a44eab2eec880108850367 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 16:09:03 -0800
Subject: [PATCH 051/159] Improved undefined/null handling for unary operators

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 434dd46d0eb..8d9b3eb3142 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14483,6 +14483,7 @@ namespace ts {
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.MinusToken:
                 case SyntaxKind.TildeToken:
+                    checkNonNullType(operandType, node.operand);
                     if (maybeTypeOfKind(operandType, TypeFlags.ESSymbol)) {
                         error(node.operand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(node.operator));
                     }
@@ -14494,7 +14495,7 @@ namespace ts {
                         booleanType;
                 case SyntaxKind.PlusPlusToken:
                 case SyntaxKind.MinusMinusToken:
-                    const ok = checkArithmeticOperandType(node.operand, getNonNullableType(operandType),
+                    const ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand),
                         Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
                     if (ok) {
                         // run check only if former checks succeeded to avoid reporting cascading errors
@@ -14510,7 +14511,7 @@ namespace ts {
             if (operandType === silentNeverType) {
                 return silentNeverType;
             }
-            const ok = checkArithmeticOperandType(node.operand, getNonNullableType(operandType),
+            const ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand),
                 Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
             if (ok) {
                 // run check only if former checks succeeded to avoid reporting cascading errors

From 221c0d7a39a31da863ea13a78e7f3b37f524e93e Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 13 Jan 2017 16:09:11 -0800
Subject: [PATCH 052/159] Accept new baselines

---
 ...bitwiseNotOperatorWithAnyOtherType.errors.txt |  8 +++++++-
 ...rWithAnyOtherTypeInvalidOperations.errors.txt | 16 +++++++++++-----
 ...rWithAnyOtherTypeInvalidOperations.errors.txt | 16 +++++++++++-----
 .../negateOperatorWithAnyOtherType.errors.txt    |  8 +++++++-
 .../plusOperatorWithAnyOtherType.errors.txt      |  8 +++++++-
 5 files changed, 43 insertions(+), 13 deletions(-)

diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
index 262ac042c68..c3e9f220a3a 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.errors.txt
@@ -1,3 +1,5 @@
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(35,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(36,24): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(47,33): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(48,26): error TS2531: Object is possibly 'null'.
@@ -6,7 +8,7 @@ tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNot
 tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts(49,38): error TS2532: Object is possibly 'undefined'.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (6 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts (8 errors) ====
     
     // ~ operator on any type
     
@@ -42,7 +44,11 @@ tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNot
     
     // any type literal
     var ResultIsNumber6 = ~undefined;
+                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber7 = ~null;
+                           ~~~~
+!!! error TS2531: Object is possibly 'null'.
     
     // any type expressions
     var ResultIsNumber8 = ~ANY2[0]
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index e5456d6f0bd..33e31bc9478 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -9,9 +9,11 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(33,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(34,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(37,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(39,26): error TS2539: Cannot assign to 'undefined' because it is not a variable.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(42,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(43,24): error TS2539: Cannot assign to 'undefined' because it is not a variable.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(46,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
@@ -56,7 +58,7 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(72,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (56 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (58 errors) ====
     // -- operator on any type
     var ANY1: any;
     var ANY2: any[] = ["", ""];
@@ -118,14 +120,18 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     var ResultIsNumber12 = --null;
                              ~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+!!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber13 = --undefined;
                              ~~~~~~~~~
 !!! error TS2539: Cannot assign to 'undefined' because it is not a variable.
     
     var ResultIsNumber14 = null--;
                            ~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+!!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+                           ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber15 = {}--;
                            ~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index bf980bfd153..afdddab86a7 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -9,9 +9,11 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(33,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(34,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(37,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(38,26): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(39,26): error TS2539: Cannot assign to 'undefined' because it is not a variable.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(41,24): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(42,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(43,24): error TS2539: Cannot assign to 'undefined' because it is not a variable.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(46,26): error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
@@ -51,7 +53,7 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (51 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (53 errors) ====
     // ++ operator on any type
     var ANY1: any;
     var ANY2: any[] = [1, 2];
@@ -113,14 +115,18 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     var ResultIsNumber12 = ++null;
                              ~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+!!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+                             ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber13 = ++undefined;
                              ~~~~~~~~~
 !!! error TS2539: Cannot assign to 'undefined' because it is not a variable.
     
     var ResultIsNumber14 = null++;
                            ~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+!!! error TS2357: The operand of an increment or decrement operator must be a variable or a property access.
+                           ~~~~
+!!! error TS2531: Object is possibly 'null'.
     var ResultIsNumber15 = {}++;
                            ~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
diff --git a/tests/baselines/reference/negateOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/negateOperatorWithAnyOtherType.errors.txt
index 03e596aca41..0fbf89fb7ec 100644
--- a/tests/baselines/reference/negateOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/negateOperatorWithAnyOtherType.errors.txt
@@ -1,7 +1,9 @@
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithAnyOtherType.ts(34,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithAnyOtherType.ts(35,23): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithAnyOtherType.ts(51,1): error TS2695: Left side of comma operator is unused and has no side effects.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithAnyOtherType.ts (1 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithAnyOtherType.ts (3 errors) ====
     // - operator on any type
     
     var ANY: any;
@@ -36,7 +38,11 @@ tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperator
     
     // any type literal
     var ResultIsNumber7 = -undefined;
+                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber = -null;
+                          ~~~~
+!!! error TS2531: Object is possibly 'null'.
     
     // any type expressions
     var ResultIsNumber8 = -ANY2[0];
diff --git a/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
index c316cf92e6d..d693aaa17d9 100644
--- a/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/plusOperatorWithAnyOtherType.errors.txt
@@ -1,3 +1,5 @@
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(34,24): error TS2532: Object is possibly 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(35,24): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(46,26): error TS2531: Object is possibly 'null'.
 tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(46,33): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(47,26): error TS2531: Object is possibly 'null'.
@@ -7,7 +9,7 @@ tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWith
 tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts(54,1): error TS2695: Left side of comma operator is unused and has no side effects.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts (7 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithAnyOtherType.ts (9 errors) ====
     // + operator on any type
     
     var ANY: any;
@@ -42,7 +44,11 @@ tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWith
     
     // any type literal
     var ResultIsNumber7 = +undefined;
+                           ~~~~~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
     var ResultIsNumber8 = +null;
+                           ~~~~
+!!! error TS2531: Object is possibly 'null'.
     
     // any type expressions
     var ResultIsNumber9 = +ANY2[0];

From 093929e49ced5d4207f69b4de822dff03103505d Mon Sep 17 00:00:00 2001
From: rdosanjh <me@rajdeep.io>
Date: Sat, 14 Jan 2017 11:02:05 +0000
Subject: [PATCH 053/159] adding 2 new lines to tsc --watch output

---
 src/compiler/tsc.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index a7304eebe4b..866065af972 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -155,7 +155,7 @@ namespace ts {
             output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `;
         }
 
-        output += `${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
+        output += `${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine + sys.newLine + sys.newLine }`;
 
         sys.write(output);
     }

From 4718efd181c2ddcc7d1203cb6ec13367ab4537b3 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sat, 14 Jan 2017 16:06:13 +0100
Subject: [PATCH 054/159] Removing es6 method/property distinction. Adding
 tests with default export and anonymous class expressions.

---
 .../staticPropertyNameConflicts.errors.txt    | 293 ++++++++++++
 .../reference/staticPropertyNameConflicts.js  | 429 ++++++++++++++++++
 ...sEs5.ts => staticPropertyNameConflicts.ts} |   0
 .../staticPropertyNameConflictsEs6.ts         |  56 ---
 4 files changed, 722 insertions(+), 56 deletions(-)
 create mode 100644 tests/baselines/reference/staticPropertyNameConflicts.errors.txt
 create mode 100644 tests/baselines/reference/staticPropertyNameConflicts.js
 rename tests/cases/conformance/classes/propertyMemberDeclarations/{staticPropertyNameConflictsEs5.ts => staticPropertyNameConflicts.ts} (100%)
 delete mode 100644 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts

diff --git a/tests/baselines/reference/staticPropertyNameConflicts.errors.txt b/tests/baselines/reference/staticPropertyNameConflicts.errors.txt
new file mode 100644
index 00000000000..4c051ace0ac
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflicts.errors.txt
@@ -0,0 +1,293 @@
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(3,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(8,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(14,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(19,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(25,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(30,12): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(30,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(36,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(41,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(47,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(52,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(62,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(67,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(73,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(78,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(84,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(89,12): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(89,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(95,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(100,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(106,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(111,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(121,16): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(128,16): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(136,16): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(143,16): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(151,16): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(158,16): error TS2300: Duplicate identifier 'prototype'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(158,16): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(166,16): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(173,16): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(181,16): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts(188,16): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+
+
+==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts (33 errors) ====
+    // name
+    class StaticName {
+        static name: number; // error
+               ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+        name: string; // ok
+    }
+    
+    class StaticNameFn {
+        static name() {} // error
+               ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+        name() {} // ok
+    }
+    
+    // length
+    class StaticLength {
+        static length: number; // error
+               ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+        length: string; // ok
+    }
+    
+    class StaticLengthFn {
+        static length() {} // error
+               ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+        length() {} // ok
+    }
+    
+    // prototype
+    class StaticPrototype {
+        static prototype: number; // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+        prototype: string; // ok
+    }
+    
+    class StaticPrototypeFn {
+        static prototype() {} // error
+               ~~~~~~~~~
+!!! error TS2300: Duplicate identifier 'prototype'.
+               ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+        prototype() {} // ok
+    }
+    
+    // caller
+    class StaticCaller {
+        static caller: number; // error
+               ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+        caller: string; // ok
+    }
+    
+    class StaticCallerFn {
+        static caller() {} // error
+               ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+        caller() {} // ok
+    }
+    
+    // arguments
+    class StaticArguments {
+        static arguments: number; // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+        arguments: string; // ok
+    }
+    
+    class StaticArgumentsFn {
+        static arguments() {} // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+        arguments() {} // ok
+    }
+    
+    
+    
+    // === Static properties on anonymous classes ===
+    
+    // name
+    var StaticName_Anonymous = class {
+        static name: number; // error
+               ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'.
+        name: string; // ok
+    }
+    
+    var StaticNameFn_Anonymous = class {
+        static name() {} // error
+               ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function '(Anonymous class)'.
+        name() {} // ok
+    }
+    
+    // length
+    var StaticLength_Anonymous = class {
+        static length: number; // error
+               ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'.
+        length: string; // ok
+    }
+    
+    var StaticLengthFn_Anonymous = class {
+        static length() {} // error
+               ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function '(Anonymous class)'.
+        length() {} // ok
+    }
+    
+    // prototype
+    var StaticPrototype_Anonymous = class {
+        static prototype: number; // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'.
+        prototype: string; // ok
+    }
+    
+    var StaticPrototypeFn_Anonymous = class {
+        static prototype() {} // error
+               ~~~~~~~~~
+!!! error TS2300: Duplicate identifier 'prototype'.
+               ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function '(Anonymous class)'.
+        prototype() {} // ok
+    }
+    
+    // caller
+    var StaticCaller_Anonymous = class {
+        static caller: number; // error
+               ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'.
+        caller: string; // ok
+    }
+    
+    var StaticCallerFn_Anonymous = class {
+        static caller() {} // error
+               ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function '(Anonymous class)'.
+        caller() {} // ok
+    }
+    
+    // arguments
+    var StaticArguments_Anonymous = class {
+        static arguments: number; // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'.
+        arguments: string; // ok
+    }
+    
+    var StaticArgumentsFn_Anonymous = class {
+        static arguments() {} // error
+               ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function '(Anonymous class)'.
+        arguments() {} // ok
+    }
+    
+    
+    // === Static properties on default exported classes ===
+    
+    // name
+    module TestOnDefaultExportedClass_1 {
+        class StaticName {
+            static name: number; // error
+                   ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
+            name: string; // ok
+        }
+    }
+    
+    module TestOnDefaultExportedClass_2 {
+        class StaticNameFn {
+            static name() {} // error
+                   ~~~~
+!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
+            name() {} // ok
+        }
+    }
+    
+    // length
+    module TestOnDefaultExportedClass_3 {
+        export default class StaticLength {
+            static length: number; // error
+                   ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
+            length: string; // ok
+        }
+    }
+    
+    module TestOnDefaultExportedClass_4 {
+        export default class StaticLengthFn {
+            static length() {} // error
+                   ~~~~~~
+!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
+            length() {} // ok
+        }
+    }
+    
+    // prototype
+    module TestOnDefaultExportedClass_5 {    
+        export default class StaticPrototype {
+            static prototype: number; // error
+                   ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
+            prototype: string; // ok
+        }
+    }
+    
+    module TestOnDefaultExportedClass_6 {
+        export default class StaticPrototypeFn {
+            static prototype() {} // error
+                   ~~~~~~~~~
+!!! error TS2300: Duplicate identifier 'prototype'.
+                   ~~~~~~~~~
+!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
+            prototype() {} // ok
+        }
+    }
+    
+    // caller
+    module TestOnDefaultExportedClass_7 {
+        export default class StaticCaller {
+            static caller: number; // error
+                   ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
+            caller: string; // ok
+        }
+    }
+    
+    module TestOnDefaultExportedClass_8 {
+        export default class StaticCallerFn {
+            static caller() {} // error
+                   ~~~~~~
+!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
+            caller() {} // ok
+        }
+    }
+    
+    // arguments
+    module TestOnDefaultExportedClass_9 {
+        export default class StaticArguments {
+            static arguments: number; // error
+                   ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
+            arguments: string; // ok
+        }
+    }
+    
+    module TestOnDefaultExportedClass_10 {
+        export default class StaticArgumentsFn {
+            static arguments() {} // error
+                   ~~~~~~~~~
+!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
+            arguments() {} // ok
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflicts.js b/tests/baselines/reference/staticPropertyNameConflicts.js
new file mode 100644
index 00000000000..b93b16550f0
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflicts.js
@@ -0,0 +1,429 @@
+//// [staticPropertyNameConflicts.ts]
+// name
+class StaticName {
+    static name: number; // error
+    name: string; // ok
+}
+
+class StaticNameFn {
+    static name() {} // error
+    name() {} // ok
+}
+
+// length
+class StaticLength {
+    static length: number; // error
+    length: string; // ok
+}
+
+class StaticLengthFn {
+    static length() {} // error
+    length() {} // ok
+}
+
+// prototype
+class StaticPrototype {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+class StaticPrototypeFn {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+// caller
+class StaticCaller {
+    static caller: number; // error
+    caller: string; // ok
+}
+
+class StaticCallerFn {
+    static caller() {} // error
+    caller() {} // ok
+}
+
+// arguments
+class StaticArguments {
+    static arguments: number; // error
+    arguments: string; // ok
+}
+
+class StaticArgumentsFn {
+    static arguments() {} // error
+    arguments() {} // ok
+}
+
+
+
+// === Static properties on anonymous classes ===
+
+// name
+var StaticName_Anonymous = class {
+    static name: number; // error
+    name: string; // ok
+}
+
+var StaticNameFn_Anonymous = class {
+    static name() {} // error
+    name() {} // ok
+}
+
+// length
+var StaticLength_Anonymous = class {
+    static length: number; // error
+    length: string; // ok
+}
+
+var StaticLengthFn_Anonymous = class {
+    static length() {} // error
+    length() {} // ok
+}
+
+// prototype
+var StaticPrototype_Anonymous = class {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+var StaticPrototypeFn_Anonymous = class {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+// caller
+var StaticCaller_Anonymous = class {
+    static caller: number; // error
+    caller: string; // ok
+}
+
+var StaticCallerFn_Anonymous = class {
+    static caller() {} // error
+    caller() {} // ok
+}
+
+// arguments
+var StaticArguments_Anonymous = class {
+    static arguments: number; // error
+    arguments: string; // ok
+}
+
+var StaticArgumentsFn_Anonymous = class {
+    static arguments() {} // error
+    arguments() {} // ok
+}
+
+
+// === Static properties on default exported classes ===
+
+// name
+module TestOnDefaultExportedClass_1 {
+    class StaticName {
+        static name: number; // error
+        name: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_2 {
+    class StaticNameFn {
+        static name() {} // error
+        name() {} // ok
+    }
+}
+
+// length
+module TestOnDefaultExportedClass_3 {
+    export default class StaticLength {
+        static length: number; // error
+        length: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_4 {
+    export default class StaticLengthFn {
+        static length() {} // error
+        length() {} // ok
+    }
+}
+
+// prototype
+module TestOnDefaultExportedClass_5 {    
+    export default class StaticPrototype {
+        static prototype: number; // error
+        prototype: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_6 {
+    export default class StaticPrototypeFn {
+        static prototype() {} // error
+        prototype() {} // ok
+    }
+}
+
+// caller
+module TestOnDefaultExportedClass_7 {
+    export default class StaticCaller {
+        static caller: number; // error
+        caller: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_8 {
+    export default class StaticCallerFn {
+        static caller() {} // error
+        caller() {} // ok
+    }
+}
+
+// arguments
+module TestOnDefaultExportedClass_9 {
+    export default class StaticArguments {
+        static arguments: number; // error
+        arguments: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_10 {
+    export default class StaticArgumentsFn {
+        static arguments() {} // error
+        arguments() {} // ok
+    }
+}
+
+//// [staticPropertyNameConflicts.js]
+// name
+var StaticName = (function () {
+    function StaticName() {
+    }
+    return StaticName;
+}());
+var StaticNameFn = (function () {
+    function StaticNameFn() {
+    }
+    StaticNameFn.name = function () { }; // error
+    StaticNameFn.prototype.name = function () { }; // ok
+    return StaticNameFn;
+}());
+// length
+var StaticLength = (function () {
+    function StaticLength() {
+    }
+    return StaticLength;
+}());
+var StaticLengthFn = (function () {
+    function StaticLengthFn() {
+    }
+    StaticLengthFn.length = function () { }; // error
+    StaticLengthFn.prototype.length = function () { }; // ok
+    return StaticLengthFn;
+}());
+// prototype
+var StaticPrototype = (function () {
+    function StaticPrototype() {
+    }
+    return StaticPrototype;
+}());
+var StaticPrototypeFn = (function () {
+    function StaticPrototypeFn() {
+    }
+    StaticPrototypeFn.prototype = function () { }; // error
+    StaticPrototypeFn.prototype.prototype = function () { }; // ok
+    return StaticPrototypeFn;
+}());
+// caller
+var StaticCaller = (function () {
+    function StaticCaller() {
+    }
+    return StaticCaller;
+}());
+var StaticCallerFn = (function () {
+    function StaticCallerFn() {
+    }
+    StaticCallerFn.caller = function () { }; // error
+    StaticCallerFn.prototype.caller = function () { }; // ok
+    return StaticCallerFn;
+}());
+// arguments
+var StaticArguments = (function () {
+    function StaticArguments() {
+    }
+    return StaticArguments;
+}());
+var StaticArgumentsFn = (function () {
+    function StaticArgumentsFn() {
+    }
+    StaticArgumentsFn.arguments = function () { }; // error
+    StaticArgumentsFn.prototype.arguments = function () { }; // ok
+    return StaticArgumentsFn;
+}());
+// === Static properties on anonymous classes ===
+// name
+var StaticName_Anonymous = (function () {
+    function class_1() {
+    }
+    return class_1;
+}());
+var StaticNameFn_Anonymous = (function () {
+    function class_2() {
+    }
+    class_2.name = function () { }; // error
+    class_2.prototype.name = function () { }; // ok
+    return class_2;
+}());
+// length
+var StaticLength_Anonymous = (function () {
+    function class_3() {
+    }
+    return class_3;
+}());
+var StaticLengthFn_Anonymous = (function () {
+    function class_4() {
+    }
+    class_4.length = function () { }; // error
+    class_4.prototype.length = function () { }; // ok
+    return class_4;
+}());
+// prototype
+var StaticPrototype_Anonymous = (function () {
+    function class_5() {
+    }
+    return class_5;
+}());
+var StaticPrototypeFn_Anonymous = (function () {
+    function class_6() {
+    }
+    class_6.prototype = function () { }; // error
+    class_6.prototype.prototype = function () { }; // ok
+    return class_6;
+}());
+// caller
+var StaticCaller_Anonymous = (function () {
+    function class_7() {
+    }
+    return class_7;
+}());
+var StaticCallerFn_Anonymous = (function () {
+    function class_8() {
+    }
+    class_8.caller = function () { }; // error
+    class_8.prototype.caller = function () { }; // ok
+    return class_8;
+}());
+// arguments
+var StaticArguments_Anonymous = (function () {
+    function class_9() {
+    }
+    return class_9;
+}());
+var StaticArgumentsFn_Anonymous = (function () {
+    function class_10() {
+    }
+    class_10.arguments = function () { }; // error
+    class_10.prototype.arguments = function () { }; // ok
+    return class_10;
+}());
+// === Static properties on default exported classes ===
+// name
+var TestOnDefaultExportedClass_1;
+(function (TestOnDefaultExportedClass_1) {
+    var StaticName = (function () {
+        function StaticName() {
+        }
+        return StaticName;
+    }());
+})(TestOnDefaultExportedClass_1 || (TestOnDefaultExportedClass_1 = {}));
+var TestOnDefaultExportedClass_2;
+(function (TestOnDefaultExportedClass_2) {
+    var StaticNameFn = (function () {
+        function StaticNameFn() {
+        }
+        StaticNameFn.name = function () { }; // error
+        StaticNameFn.prototype.name = function () { }; // ok
+        return StaticNameFn;
+    }());
+})(TestOnDefaultExportedClass_2 || (TestOnDefaultExportedClass_2 = {}));
+// length
+var TestOnDefaultExportedClass_3;
+(function (TestOnDefaultExportedClass_3) {
+    var StaticLength = (function () {
+        function StaticLength() {
+        }
+        return StaticLength;
+    }());
+    TestOnDefaultExportedClass_3.StaticLength = StaticLength;
+})(TestOnDefaultExportedClass_3 || (TestOnDefaultExportedClass_3 = {}));
+var TestOnDefaultExportedClass_4;
+(function (TestOnDefaultExportedClass_4) {
+    var StaticLengthFn = (function () {
+        function StaticLengthFn() {
+        }
+        StaticLengthFn.length = function () { }; // error
+        StaticLengthFn.prototype.length = function () { }; // ok
+        return StaticLengthFn;
+    }());
+    TestOnDefaultExportedClass_4.StaticLengthFn = StaticLengthFn;
+})(TestOnDefaultExportedClass_4 || (TestOnDefaultExportedClass_4 = {}));
+// prototype
+var TestOnDefaultExportedClass_5;
+(function (TestOnDefaultExportedClass_5) {
+    var StaticPrototype = (function () {
+        function StaticPrototype() {
+        }
+        return StaticPrototype;
+    }());
+    TestOnDefaultExportedClass_5.StaticPrototype = StaticPrototype;
+})(TestOnDefaultExportedClass_5 || (TestOnDefaultExportedClass_5 = {}));
+var TestOnDefaultExportedClass_6;
+(function (TestOnDefaultExportedClass_6) {
+    var StaticPrototypeFn = (function () {
+        function StaticPrototypeFn() {
+        }
+        StaticPrototypeFn.prototype = function () { }; // error
+        StaticPrototypeFn.prototype.prototype = function () { }; // ok
+        return StaticPrototypeFn;
+    }());
+    TestOnDefaultExportedClass_6.StaticPrototypeFn = StaticPrototypeFn;
+})(TestOnDefaultExportedClass_6 || (TestOnDefaultExportedClass_6 = {}));
+// caller
+var TestOnDefaultExportedClass_7;
+(function (TestOnDefaultExportedClass_7) {
+    var StaticCaller = (function () {
+        function StaticCaller() {
+        }
+        return StaticCaller;
+    }());
+    TestOnDefaultExportedClass_7.StaticCaller = StaticCaller;
+})(TestOnDefaultExportedClass_7 || (TestOnDefaultExportedClass_7 = {}));
+var TestOnDefaultExportedClass_8;
+(function (TestOnDefaultExportedClass_8) {
+    var StaticCallerFn = (function () {
+        function StaticCallerFn() {
+        }
+        StaticCallerFn.caller = function () { }; // error
+        StaticCallerFn.prototype.caller = function () { }; // ok
+        return StaticCallerFn;
+    }());
+    TestOnDefaultExportedClass_8.StaticCallerFn = StaticCallerFn;
+})(TestOnDefaultExportedClass_8 || (TestOnDefaultExportedClass_8 = {}));
+// arguments
+var TestOnDefaultExportedClass_9;
+(function (TestOnDefaultExportedClass_9) {
+    var StaticArguments = (function () {
+        function StaticArguments() {
+        }
+        return StaticArguments;
+    }());
+    TestOnDefaultExportedClass_9.StaticArguments = StaticArguments;
+})(TestOnDefaultExportedClass_9 || (TestOnDefaultExportedClass_9 = {}));
+var TestOnDefaultExportedClass_10;
+(function (TestOnDefaultExportedClass_10) {
+    var StaticArgumentsFn = (function () {
+        function StaticArgumentsFn() {
+        }
+        StaticArgumentsFn.arguments = function () { }; // error
+        StaticArgumentsFn.prototype.arguments = function () { }; // ok
+        return StaticArgumentsFn;
+    }());
+    TestOnDefaultExportedClass_10.StaticArgumentsFn = StaticArgumentsFn;
+})(TestOnDefaultExportedClass_10 || (TestOnDefaultExportedClass_10 = {}));
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts
similarity index 100%
rename from tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts
rename to tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
deleted file mode 100644
index 1b93e98dae8..00000000000
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-// @target: es6
-
-
-class StaticName {
-    static name: number; // error
-    name: string; // ok
-}
-
-class StaticNameFn {
-    static name() {}  // ok
-    name() {} // ok
-}
-
-
-class StaticLength {
-    static length: number;  // error
-    length: string; // ok
-}
-
-class StaticLengthFn {
-    static length() {} // ok
-    length() {} // ok
-}
-
-
-class StaticPrototype {
-    static prototype: number; // error
-    prototype: string; // ok
-}
-
-class StaticPrototypeFn {
-    static prototype() {} // error
-    prototype() {} // ok
-}
-
-
-class StaticCaller {
-    static caller: number; // error
-    caller: string; // ok
-}
-
-class StaticCallerFn {
-    static caller() {} // ok
-    caller() {} // ok
-}
-
-
-class StaticArguments {
-    static arguments: number; // error
-    arguments: string; // ok
-}
-
-class StaticArgumentsFn {
-    static arguments() {} // ok
-    arguments() {} // ok
-}

From 9b217e31df0898c229619f1e7465225f97ed5720 Mon Sep 17 00:00:00 2001
From: about-code <about-code@users.noreply.github.com>
Date: Sat, 14 Jan 2017 16:30:12 +0100
Subject: [PATCH 055/159] Removing es6 method/property distinction. Adding
 tests with default export and anonymous class expressions.

---
 src/compiler/checker.ts                       |  40 ++---
 .../staticPropertyNameConflictsEs5.errors.txt |  92 -----------
 .../staticPropertyNameConflictsEs5.js         | 120 --------------
 .../staticPropertyNameConflictsEs6.errors.txt |  80 ----------
 .../staticPropertyNameConflictsEs6.js         |  89 -----------
 .../staticPropertyNameConflicts.ts            | 150 +++++++++++++++++-
 6 files changed, 155 insertions(+), 416 deletions(-)
 delete mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
 delete mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs5.js
 delete mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
 delete mode 100644 tests/baselines/reference/staticPropertyNameConflictsEs6.js

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 884860d6b14..da6235b6d1c 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -15694,8 +15694,8 @@ namespace ts {
         }
 
         /** 
-         * Static members being set on a constructor function may conflict with built-in Function 
-         * object properties. Esp. in ECMAScript 5 there are non-configurable and non-writable 
+         * Static members being set on a constructor function may conflict with built-in properties
+         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable 
          * built-in properties. This check issues a transpile error when a class has a static 
          * member with the same name as a non-writable built-in property.
          * 
@@ -15705,37 +15705,21 @@ namespace ts {
          * @see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances
          */
         function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) {
-            const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
-            const className = getNameOfSymbol(getSymbolOfNode(node));
             for (const member of node.members) {
-                const isStatic = getModifierFlags(member) & ModifierFlags.Static;
-                const isMethod = member.kind === SyntaxKind.MethodDeclaration;
                 const memberNameNode = member.name;
+                const isStatic = getModifierFlags(member) & ModifierFlags.Static;
                 if (isStatic && memberNameNode) {
                     const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
-                    if (languageVersion <= ScriptTarget.ES5) {  // ES3, ES5
-                        if (memberName === "prototype" ||
-                            memberName === "name" ||
-                            memberName === "length" ||
-                            memberName === "caller" ||
-                            memberName === "arguments"
-                        ) {
+                    switch (memberName) {
+                        case "name":
+                        case "length":
+                        case "caller":
+                        case "arguments":
+                        case "prototype":
+                            const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
+                            const className = getNameOfSymbol(getSymbolOfNode(node));
                             error(memberNameNode, message, memberName, className);
-                        }
-                    }
-                    else { // ES6+
-                        if (memberName === "prototype") {
-                            error(memberNameNode, message, memberName, className);
-                        }
-                        else if ((
-                            memberName === "name" ||
-                            memberName === "length" ||
-                            memberName === "caller" ||
-                            memberName === "arguments") &&
-                            isMethod === false
-                        ) {
-                            error(memberNameNode, message, memberName, className);
-                        }
+                            break;
                     }
                 }
             }
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
deleted file mode 100644
index 004365d3e76..00000000000
--- a/tests/baselines/reference/staticPropertyNameConflictsEs5.errors.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(4,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(9,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(15,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(20,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(26,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(37,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(42,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts(53,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
-
-
-==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs5.ts (11 errors) ====
-    
-    // static name
-    class StaticName {
-        static name: number; // error
-               ~~~~
-!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-        name: string; // ok
-    }
-    
-    class StaticNameFn {
-        static name() {} // error
-               ~~~~
-!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticNameFn'.
-        name() {} // ok
-    }
-    
-    
-    class StaticLength {
-        static length: number; // error
-               ~~~~~~
-!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-        length: string; // ok
-    }
-    
-    class StaticLengthFn {
-        static length() {} // error
-               ~~~~~~
-!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLengthFn'.
-        length() {} // ok
-    }
-    
-    
-    class StaticPrototype {
-        static prototype: number; // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
-        prototype: string; // ok
-    }
-    
-    class StaticPrototypeFn {
-        static prototype() {} // error
-               ~~~~~~~~~
-!!! error TS2300: Duplicate identifier 'prototype'.
-               ~~~~~~~~~
-!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-        prototype() {} // ok
-    }
-    
-    
-    class StaticCaller {
-        static caller: number; // error
-               ~~~~~~
-!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-        caller: string; // ok
-    }
-    
-    class StaticCallerFn {
-        static caller() {} // error
-               ~~~~~~
-!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCallerFn'.
-        caller() {} // ok
-    }
-    
-    
-    class StaticArguments {
-        static arguments: number; // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-        arguments: string; // ok
-    }
-    
-    class StaticArgumentsFn {
-        static arguments() {} // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArgumentsFn'.
-        arguments() {} // ok
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs5.js b/tests/baselines/reference/staticPropertyNameConflictsEs5.js
deleted file mode 100644
index 06d4a011a8e..00000000000
--- a/tests/baselines/reference/staticPropertyNameConflictsEs5.js
+++ /dev/null
@@ -1,120 +0,0 @@
-//// [staticPropertyNameConflictsEs5.ts]
-
-// static name
-class StaticName {
-    static name: number; // error
-    name: string; // ok
-}
-
-class StaticNameFn {
-    static name() {} // error
-    name() {} // ok
-}
-
-
-class StaticLength {
-    static length: number; // error
-    length: string; // ok
-}
-
-class StaticLengthFn {
-    static length() {} // error
-    length() {} // ok
-}
-
-
-class StaticPrototype {
-    static prototype: number; // error
-    prototype: string; // ok
-}
-
-class StaticPrototypeFn {
-    static prototype() {} // error
-    prototype() {} // ok
-}
-
-
-class StaticCaller {
-    static caller: number; // error
-    caller: string; // ok
-}
-
-class StaticCallerFn {
-    static caller() {} // error
-    caller() {} // ok
-}
-
-
-class StaticArguments {
-    static arguments: number; // error
-    arguments: string; // ok
-}
-
-class StaticArgumentsFn {
-    static arguments() {} // error
-    arguments() {} // ok
-}
-
-
-//// [staticPropertyNameConflictsEs5.js]
-// static name
-var StaticName = (function () {
-    function StaticName() {
-    }
-    return StaticName;
-}());
-var StaticNameFn = (function () {
-    function StaticNameFn() {
-    }
-    StaticNameFn.name = function () { }; // error
-    StaticNameFn.prototype.name = function () { }; // ok
-    return StaticNameFn;
-}());
-var StaticLength = (function () {
-    function StaticLength() {
-    }
-    return StaticLength;
-}());
-var StaticLengthFn = (function () {
-    function StaticLengthFn() {
-    }
-    StaticLengthFn.length = function () { }; // error
-    StaticLengthFn.prototype.length = function () { }; // ok
-    return StaticLengthFn;
-}());
-var StaticPrototype = (function () {
-    function StaticPrototype() {
-    }
-    return StaticPrototype;
-}());
-var StaticPrototypeFn = (function () {
-    function StaticPrototypeFn() {
-    }
-    StaticPrototypeFn.prototype = function () { }; // error
-    StaticPrototypeFn.prototype.prototype = function () { }; // ok
-    return StaticPrototypeFn;
-}());
-var StaticCaller = (function () {
-    function StaticCaller() {
-    }
-    return StaticCaller;
-}());
-var StaticCallerFn = (function () {
-    function StaticCallerFn() {
-    }
-    StaticCallerFn.caller = function () { }; // error
-    StaticCallerFn.prototype.caller = function () { }; // ok
-    return StaticCallerFn;
-}());
-var StaticArguments = (function () {
-    function StaticArguments() {
-    }
-    return StaticArguments;
-}());
-var StaticArgumentsFn = (function () {
-    function StaticArgumentsFn() {
-    }
-    StaticArgumentsFn.arguments = function () { }; // error
-    StaticArgumentsFn.prototype.arguments = function () { }; // ok
-    return StaticArgumentsFn;
-}());
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt b/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
deleted file mode 100644
index 607735bb12f..00000000000
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.errors.txt
+++ /dev/null
@@ -1,80 +0,0 @@
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(4,12): error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(15,12): error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(26,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2300: Duplicate identifier 'prototype'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(31,12): error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(37,12): error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts(48,12): error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-
-
-==== tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsEs6.ts (7 errors) ====
-    
-    
-    class StaticName {
-        static name: number; // error
-               ~~~~
-!!! error TS2699: Static property 'name' conflicts with built-in property 'Function.name' of constructor function 'StaticName'.
-        name: string; // ok
-    }
-    
-    class StaticNameFn {
-        static name() {}  // ok
-        name() {} // ok
-    }
-    
-    
-    class StaticLength {
-        static length: number;  // error
-               ~~~~~~
-!!! error TS2699: Static property 'length' conflicts with built-in property 'Function.length' of constructor function 'StaticLength'.
-        length: string; // ok
-    }
-    
-    class StaticLengthFn {
-        static length() {} // ok
-        length() {} // ok
-    }
-    
-    
-    class StaticPrototype {
-        static prototype: number; // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototype'.
-        prototype: string; // ok
-    }
-    
-    class StaticPrototypeFn {
-        static prototype() {} // error
-               ~~~~~~~~~
-!!! error TS2300: Duplicate identifier 'prototype'.
-               ~~~~~~~~~
-!!! error TS2699: Static property 'prototype' conflicts with built-in property 'Function.prototype' of constructor function 'StaticPrototypeFn'.
-        prototype() {} // ok
-    }
-    
-    
-    class StaticCaller {
-        static caller: number; // error
-               ~~~~~~
-!!! error TS2699: Static property 'caller' conflicts with built-in property 'Function.caller' of constructor function 'StaticCaller'.
-        caller: string; // ok
-    }
-    
-    class StaticCallerFn {
-        static caller() {} // ok
-        caller() {} // ok
-    }
-    
-    
-    class StaticArguments {
-        static arguments: number; // error
-               ~~~~~~~~~
-!!! error TS2699: Static property 'arguments' conflicts with built-in property 'Function.arguments' of constructor function 'StaticArguments'.
-        arguments: string; // ok
-    }
-    
-    class StaticArgumentsFn {
-        static arguments() {} // ok
-        arguments() {} // ok
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/staticPropertyNameConflictsEs6.js b/tests/baselines/reference/staticPropertyNameConflictsEs6.js
deleted file mode 100644
index 7adef10b141..00000000000
--- a/tests/baselines/reference/staticPropertyNameConflictsEs6.js
+++ /dev/null
@@ -1,89 +0,0 @@
-//// [staticPropertyNameConflictsEs6.ts]
-
-
-class StaticName {
-    static name: number; // error
-    name: string; // ok
-}
-
-class StaticNameFn {
-    static name() {}  // ok
-    name() {} // ok
-}
-
-
-class StaticLength {
-    static length: number;  // error
-    length: string; // ok
-}
-
-class StaticLengthFn {
-    static length() {} // ok
-    length() {} // ok
-}
-
-
-class StaticPrototype {
-    static prototype: number; // error
-    prototype: string; // ok
-}
-
-class StaticPrototypeFn {
-    static prototype() {} // error
-    prototype() {} // ok
-}
-
-
-class StaticCaller {
-    static caller: number; // error
-    caller: string; // ok
-}
-
-class StaticCallerFn {
-    static caller() {} // ok
-    caller() {} // ok
-}
-
-
-class StaticArguments {
-    static arguments: number; // error
-    arguments: string; // ok
-}
-
-class StaticArgumentsFn {
-    static arguments() {} // ok
-    arguments() {} // ok
-}
-
-
-//// [staticPropertyNameConflictsEs6.js]
-class StaticName {
-}
-class StaticNameFn {
-    static name() { } // ok
-    name() { } // ok
-}
-class StaticLength {
-}
-class StaticLengthFn {
-    static length() { } // ok
-    length() { } // ok
-}
-class StaticPrototype {
-}
-class StaticPrototypeFn {
-    static prototype() { } // error
-    prototype() { } // ok
-}
-class StaticCaller {
-}
-class StaticCallerFn {
-    static caller() { } // ok
-    caller() { } // ok
-}
-class StaticArguments {
-}
-class StaticArgumentsFn {
-    static arguments() { } // ok
-    arguments() { } // ok
-}
diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts
index 5eb09ddb2d3..86755cb016d 100644
--- a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflicts.ts
@@ -1,6 +1,5 @@
-// @target: es5   
-
-// static name
+// @target: es5
+// name
 class StaticName {
     static name: number; // error
     name: string; // ok
@@ -11,7 +10,7 @@ class StaticNameFn {
     name() {} // ok
 }
 
-
+// length
 class StaticLength {
     static length: number; // error
     length: string; // ok
@@ -22,7 +21,7 @@ class StaticLengthFn {
     length() {} // ok
 }
 
-
+// prototype
 class StaticPrototype {
     static prototype: number; // error
     prototype: string; // ok
@@ -33,7 +32,7 @@ class StaticPrototypeFn {
     prototype() {} // ok
 }
 
-
+// caller
 class StaticCaller {
     static caller: number; // error
     caller: string; // ok
@@ -44,7 +43,7 @@ class StaticCallerFn {
     caller() {} // ok
 }
 
-
+// arguments
 class StaticArguments {
     static arguments: number; // error
     arguments: string; // ok
@@ -54,3 +53,140 @@ class StaticArgumentsFn {
     static arguments() {} // error
     arguments() {} // ok
 }
+
+
+
+// === Static properties on anonymous classes ===
+
+// name
+var StaticName_Anonymous = class {
+    static name: number; // error
+    name: string; // ok
+}
+
+var StaticNameFn_Anonymous = class {
+    static name() {} // error
+    name() {} // ok
+}
+
+// length
+var StaticLength_Anonymous = class {
+    static length: number; // error
+    length: string; // ok
+}
+
+var StaticLengthFn_Anonymous = class {
+    static length() {} // error
+    length() {} // ok
+}
+
+// prototype
+var StaticPrototype_Anonymous = class {
+    static prototype: number; // error
+    prototype: string; // ok
+}
+
+var StaticPrototypeFn_Anonymous = class {
+    static prototype() {} // error
+    prototype() {} // ok
+}
+
+// caller
+var StaticCaller_Anonymous = class {
+    static caller: number; // error
+    caller: string; // ok
+}
+
+var StaticCallerFn_Anonymous = class {
+    static caller() {} // error
+    caller() {} // ok
+}
+
+// arguments
+var StaticArguments_Anonymous = class {
+    static arguments: number; // error
+    arguments: string; // ok
+}
+
+var StaticArgumentsFn_Anonymous = class {
+    static arguments() {} // error
+    arguments() {} // ok
+}
+
+
+// === Static properties on default exported classes ===
+
+// name
+module TestOnDefaultExportedClass_1 {
+    class StaticName {
+        static name: number; // error
+        name: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_2 {
+    class StaticNameFn {
+        static name() {} // error
+        name() {} // ok
+    }
+}
+
+// length
+module TestOnDefaultExportedClass_3 {
+    export default class StaticLength {
+        static length: number; // error
+        length: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_4 {
+    export default class StaticLengthFn {
+        static length() {} // error
+        length() {} // ok
+    }
+}
+
+// prototype
+module TestOnDefaultExportedClass_5 {    
+    export default class StaticPrototype {
+        static prototype: number; // error
+        prototype: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_6 {
+    export default class StaticPrototypeFn {
+        static prototype() {} // error
+        prototype() {} // ok
+    }
+}
+
+// caller
+module TestOnDefaultExportedClass_7 {
+    export default class StaticCaller {
+        static caller: number; // error
+        caller: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_8 {
+    export default class StaticCallerFn {
+        static caller() {} // error
+        caller() {} // ok
+    }
+}
+
+// arguments
+module TestOnDefaultExportedClass_9 {
+    export default class StaticArguments {
+        static arguments: number; // error
+        arguments: string; // ok
+    }
+}
+
+module TestOnDefaultExportedClass_10 {
+    export default class StaticArgumentsFn {
+        static arguments() {} // error
+        arguments() {} // ok
+    }
+}
\ No newline at end of file

From 061175ef9fb6ab985de56b9c4b49db4bdd4d272a Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Sun, 15 Jan 2017 16:26:17 -0800
Subject: [PATCH 056/159] Emit 'object' type in declaration emitter

---
 src/compiler/declarationEmitter.ts             |  1 +
 .../reference/nonPrimitiveAsProperty.js        |  8 ++++++++
 .../reference/nonPrimitiveInFunction.js        |  8 ++++++++
 .../reference/nonPrimitiveInGeneric.js         | 18 ++++++++++++++++++
 .../reference/nonPrimitiveUnionIntersection.js |  5 +++++
 .../nonPrimitive/nonPrimitiveAsProperty.ts     |  1 +
 .../nonPrimitive/nonPrimitiveInFunction.ts     |  1 +
 .../nonPrimitive/nonPrimitiveInGeneric.ts      |  1 +
 .../nonPrimitiveUnionIntersection.ts           |  1 +
 9 files changed, 44 insertions(+)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index cd98622e080..bdeb700f1d1 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -390,6 +390,7 @@ namespace ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.ObjectKeyword:
                 case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.UndefinedKeyword:
diff --git a/tests/baselines/reference/nonPrimitiveAsProperty.js b/tests/baselines/reference/nonPrimitiveAsProperty.js
index f51a9b35435..d3e1b072a06 100644
--- a/tests/baselines/reference/nonPrimitiveAsProperty.js
+++ b/tests/baselines/reference/nonPrimitiveAsProperty.js
@@ -11,3 +11,11 @@ var b: WithNonPrimitive = {foo: "bar"}; // expect error
 //// [nonPrimitiveAsProperty.js]
 var a = { foo: { bar: "bar" } };
 var b = { foo: "bar" }; // expect error
+
+
+//// [nonPrimitiveAsProperty.d.ts]
+interface WithNonPrimitive {
+    foo: object;
+}
+declare var a: WithNonPrimitive;
+declare var b: WithNonPrimitive;
diff --git a/tests/baselines/reference/nonPrimitiveInFunction.js b/tests/baselines/reference/nonPrimitiveInFunction.js
index a67b68542dd..1d2a2462502 100644
--- a/tests/baselines/reference/nonPrimitiveInFunction.js
+++ b/tests/baselines/reference/nonPrimitiveInFunction.js
@@ -34,3 +34,11 @@ function returnError() {
     var ret = 123;
     return ret; // expect error
 }
+
+
+//// [nonPrimitiveInFunction.d.ts]
+declare function takeObject(o: object): void;
+declare function returnObject(): object;
+declare var nonPrimitive: object;
+declare var primitive: boolean;
+declare function returnError(): object;
diff --git a/tests/baselines/reference/nonPrimitiveInGeneric.js b/tests/baselines/reference/nonPrimitiveInGeneric.js
index 2db357c3eb5..d7e013c71f1 100644
--- a/tests/baselines/reference/nonPrimitiveInGeneric.js
+++ b/tests/baselines/reference/nonPrimitiveInGeneric.js
@@ -73,3 +73,21 @@ var x; // error
 var y; // ok
 var z; // ok
 var u; // ok
+
+
+//// [nonPrimitiveInGeneric.d.ts]
+declare function generic<T>(t: T): void;
+declare var a: {};
+declare var b: string;
+declare function bound<T extends object>(t: T): void;
+declare function bound2<T extends object>(): void;
+declare function bound3<T extends {}>(t: T): void;
+interface Proxy<T extends object> {
+}
+declare var x: Proxy<number>;
+declare var y: Proxy<null>;
+declare var z: Proxy<undefined>;
+interface Blah {
+    foo: number;
+}
+declare var u: Proxy<Blah>;
diff --git a/tests/baselines/reference/nonPrimitiveUnionIntersection.js b/tests/baselines/reference/nonPrimitiveUnionIntersection.js
index c50a2330018..7f4b46c42ed 100644
--- a/tests/baselines/reference/nonPrimitiveUnionIntersection.js
+++ b/tests/baselines/reference/nonPrimitiveUnionIntersection.js
@@ -10,3 +10,8 @@ var a = ""; // error
 var b = ""; // ok
 a = b; // error
 b = a; // ok
+
+
+//// [nonPrimitiveUnionIntersection.d.ts]
+declare var a: object & string;
+declare var b: object | string;
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAsProperty.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAsProperty.ts
index ee4011ecf7d..3cd2ce4cef5 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAsProperty.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAsProperty.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 interface WithNonPrimitive {
     foo: object
 }
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInFunction.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInFunction.ts
index c38693dbfb1..d56c02fafe9 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInFunction.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInFunction.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 function takeObject(o: object) {}
 function returnObject(): object {
     return {};
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts
index 836896b5a57..490a9f88135 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 function generic<T>(t: T) {
     var o: object = t; // expect error
 }
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
index c1667c7a32e..a9d5872705c 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 var a: object & string = ""; // error
 var b: object | string = ""; // ok
 a = b; // error

From 919e682e3f53ee8dbc914c27d04763406e29becb Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 16 Jan 2017 12:18:01 -0800
Subject: [PATCH 057/159] Allow T[N] where N is numeric and T has apparent
 numeric index signature

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 80516ef9319..9ea61bc2655 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -16032,14 +16032,24 @@ namespace ts {
         }
 
         function checkIndexedAccessIndexType(type: Type, accessNode: ElementAccessExpression | IndexedAccessTypeNode) {
-            if (type.flags & TypeFlags.IndexedAccess) {
-                // Check that the index type is assignable to 'keyof T' for the object type.
-                const objectType = (<IndexedAccessType>type).objectType;
-                const indexType = (<IndexedAccessType>type).indexType;
-                if (!isTypeAssignableTo(indexType, getIndexType(objectType))) {
-                    error(accessNode, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
+            if (!(type.flags & TypeFlags.IndexedAccess)) {
+                return type;
+            }
+            // Check if the index type is assignable to 'keyof T' for the object type.
+            const objectType = (<IndexedAccessType>type).objectType;
+            const indexType = (<IndexedAccessType>type).indexType;
+            if (isTypeAssignableTo(indexType, getIndexType(objectType))) {
+                return type;
+            }
+            // Check if we're indexing with a numeric type and the object type is a generic
+            // type with a constraint that has a numeric index signature.
+            if (maybeTypeOfKind(objectType, TypeFlags.TypeVariable) && isTypeOfKind(indexType, TypeFlags.NumberLike)) {
+                const constraint = getBaseConstraintOfType(<TypeVariable | UnionOrIntersectionType>objectType);
+                if (constraint && getIndexInfoOfType(constraint, IndexKind.Number)) {
+                    return type;
                 }
             }
+            error(accessNode, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
             return type;
         }
 

From f7d8e3befccd86c348d69083fdf823c49169ee06 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 16 Jan 2017 12:18:15 -0800
Subject: [PATCH 058/159] Add regression test

---
 tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
index 27e47da177c..a4088e65df4 100644
--- a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
+++ b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
@@ -501,3 +501,7 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
     var x = obj[key];
     stringMap[x]; // Should be OK.
 }
+
+// Repro from #13514
+
+declare function head<T extends Array<any>>(list: T): T[0];

From 59a8aa4d828fde5a69b0e76f788ec1366bcc2f6e Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 16 Jan 2017 14:30:24 -0800
Subject: [PATCH 059/159] Accept new baselines

---
 tests/baselines/reference/keyofAndIndexedAccess.js     |  5 +++++
 .../baselines/reference/keyofAndIndexedAccess.symbols  | 10 ++++++++++
 tests/baselines/reference/keyofAndIndexedAccess.types  | 10 ++++++++++
 3 files changed, 25 insertions(+)

diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js
index 05658d50515..a86184c8ff0 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.js
+++ b/tests/baselines/reference/keyofAndIndexedAccess.js
@@ -500,6 +500,10 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
     var x = obj[key];
     stringMap[x]; // Should be OK.
 }
+
+// Repro from #13514
+
+declare function head<T extends Array<any>>(list: T): T[0];
 
 
 //// [keyofAndIndexedAccess.js]
@@ -1061,3 +1065,4 @@ declare function updateIds2<T extends {
 }, K extends keyof T>(obj: T, key: K, stringMap: {
     [oldId: string]: string;
 }): void;
+declare function head<T extends Array<any>>(list: T): T[0];
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index d7bc419af24..4c12c6554c9 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -1806,3 +1806,13 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
 >x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 498, 7))
 }
 
+// Repro from #13514
+
+declare function head<T extends Array<any>>(list: T): T[0];
+>head : Symbol(head, Decl(keyofAndIndexedAccess.ts, 500, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>list : Symbol(list, Decl(keyofAndIndexedAccess.ts, 504, 44))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22))
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index 543c39b3c92..3919d768151 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -2128,3 +2128,13 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
 >x : T[K]
 }
 
+// Repro from #13514
+
+declare function head<T extends Array<any>>(list: T): T[0];
+>head : <T extends any[]>(list: T) => T[0]
+>T : T
+>Array : T[]
+>list : T
+>T : T
+>T : T
+

From f1e7142f3c7e74224a15780651f86330fbadfd90 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 07:42:31 -0800
Subject: [PATCH 060/159] Move code out of closure in
 `getCompletionsAtPosition`

---
 src/services/completions.ts | 1145 ++++++++++++++++++-----------------
 1 file changed, 573 insertions(+), 572 deletions(-)

diff --git a/src/services/completions.ts b/src/services/completions.ts
index 8c0d52b2c34..acb78772132 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -1,12 +1,14 @@
 /* @internal */
 namespace ts.Completions {
-    export function getCompletionsAtPosition(host: LanguageServiceHost, typeChecker: TypeChecker, log: (message: string) => void, compilerOptions: CompilerOptions, sourceFile: SourceFile, position: number): CompletionInfo | undefined {
+    type Log = (message: string) => void;
+
+    export function getCompletionsAtPosition(host: LanguageServiceHost, typeChecker: TypeChecker, log: Log, compilerOptions: CompilerOptions, sourceFile: SourceFile, position: number): CompletionInfo | undefined {
         if (isInReferenceComment(sourceFile, position)) {
-            return getTripleSlashReferenceCompletion(sourceFile, position);
+            return getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions, host);
         }
 
         if (isInString(sourceFile, position)) {
-            return getStringLiteralCompletionEntries(sourceFile, position);
+            return getStringLiteralCompletionEntries(sourceFile, position, typeChecker, compilerOptions, host, log);
         }
 
         const completionData = getCompletionData(typeChecker, log, sourceFile, position);
@@ -24,8 +26,8 @@ namespace ts.Completions {
         const entries: CompletionEntry[] = [];
 
         if (isSourceFileJavaScript(sourceFile)) {
-            const uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true);
-            addRange(entries, getJavaScriptCompletionEntries(sourceFile, location.pos, uniqueNames));
+            const uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true, typeChecker, compilerOptions.target, log);
+            addRange(entries, getJavaScriptCompletionEntries(sourceFile, location.pos, uniqueNames, compilerOptions.target));
         }
         else {
             if (!symbols || symbols.length === 0) {
@@ -48,7 +50,7 @@ namespace ts.Completions {
                 }
             }
 
-            getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true);
+            getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true, typeChecker, compilerOptions.target, log);
         }
 
         // Add keywords if this is not a member completion list
@@ -57,693 +59,692 @@ namespace ts.Completions {
         }
 
         return { isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation: isNewIdentifierLocation, entries };
+    }
 
-        function getJavaScriptCompletionEntries(sourceFile: SourceFile, position: number, uniqueNames: Map<string>): CompletionEntry[] {
-            const entries: CompletionEntry[] = [];
+    function getJavaScriptCompletionEntries(sourceFile: SourceFile, position: number, uniqueNames: Map<string>, target: ScriptTarget): CompletionEntry[] {
+        const entries: CompletionEntry[] = [];
 
-            const nameTable = getNameTable(sourceFile);
-            for (const name in nameTable) {
-                // Skip identifiers produced only from the current location
-                if (nameTable[name] === position) {
-                    continue;
+        const nameTable = getNameTable(sourceFile);
+        for (const name in nameTable) {
+            // Skip identifiers produced only from the current location
+            if (nameTable[name] === position) {
+                continue;
+            }
+
+            if (!uniqueNames[name]) {
+                uniqueNames[name] = name;
+                const displayName = getCompletionEntryDisplayName(unescapeIdentifier(name), target, /*performCharacterChecks*/ true);
+                if (displayName) {
+                    const entry = {
+                        name: displayName,
+                        kind: ScriptElementKind.warning,
+                        kindModifiers: "",
+                        sortText: "1"
+                    };
+                    entries.push(entry);
                 }
+            }
+        }
 
-                if (!uniqueNames[name]) {
-                    uniqueNames[name] = name;
-                    const displayName = getCompletionEntryDisplayName(unescapeIdentifier(name), compilerOptions.target, /*performCharacterChecks*/ true);
-                    if (displayName) {
-                        const entry = {
-                            name: displayName,
-                            kind: ScriptElementKind.warning,
-                            kindModifiers: "",
-                            sortText: "1"
-                        };
+        return entries;
+    }
+
+    function createCompletionEntry(symbol: Symbol, location: Node, performCharacterChecks: boolean, typeChecker: TypeChecker, target: ScriptTarget): CompletionEntry {
+        // Try to get a valid display name for this symbol, if we could not find one, then ignore it.
+        // We would like to only show things that can be added after a dot, so for instance numeric properties can
+        // not be accessed with a dot (a.1 <- invalid)
+        const displayName = getCompletionEntryDisplayNameForSymbol(typeChecker, symbol, target, performCharacterChecks, location);
+        if (!displayName) {
+            return undefined;
+        }
+
+        // TODO(drosen): Right now we just permit *all* semantic meanings when calling
+        // 'getSymbolKind' which is permissible given that it is backwards compatible; but
+        // really we should consider passing the meaning for the node so that we don't report
+        // that a suggestion for a value is an interface.  We COULD also just do what
+        // 'getSymbolModifiers' does, which is to use the first declaration.
+
+        // Use a 'sortText' of 0' so that all symbol completion entries come before any other
+        // entries (like JavaScript identifier entries).
+        return {
+            name: displayName,
+            kind: SymbolDisplay.getSymbolKind(typeChecker, symbol, location),
+            kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
+            sortText: "0",
+        };
+    }
+
+    function getCompletionEntriesFromSymbols(symbols: Symbol[], entries: Push<CompletionEntry>, location: Node, performCharacterChecks: boolean, typeChecker: TypeChecker, target: ScriptTarget, log: Log): Map<string> {
+        const start = timestamp();
+        const uniqueNames = createMap<string>();
+        if (symbols) {
+            for (const symbol of symbols) {
+                const entry = createCompletionEntry(symbol, location, performCharacterChecks, typeChecker, target);
+                if (entry) {
+                    const id = escapeIdentifier(entry.name);
+                    if (!uniqueNames[id]) {
                         entries.push(entry);
+                        uniqueNames[id] = id;
                     }
                 }
             }
-
-            return entries;
         }
 
-        function createCompletionEntry(symbol: Symbol, location: Node, performCharacterChecks: boolean): CompletionEntry {
-            // Try to get a valid display name for this symbol, if we could not find one, then ignore it.
-            // We would like to only show things that can be added after a dot, so for instance numeric properties can
-            // not be accessed with a dot (a.1 <- invalid)
-            const displayName = getCompletionEntryDisplayNameForSymbol(typeChecker, symbol, compilerOptions.target, performCharacterChecks, location);
-            if (!displayName) {
-                return undefined;
-            }
-
-            // TODO(drosen): Right now we just permit *all* semantic meanings when calling
-            // 'getSymbolKind' which is permissible given that it is backwards compatible; but
-            // really we should consider passing the meaning for the node so that we don't report
-            // that a suggestion for a value is an interface.  We COULD also just do what
-            // 'getSymbolModifiers' does, which is to use the first declaration.
-
-            // Use a 'sortText' of 0' so that all symbol completion entries come before any other
-            // entries (like JavaScript identifier entries).
-            return {
-                name: displayName,
-                kind: SymbolDisplay.getSymbolKind(typeChecker, symbol, location),
-                kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
-                sortText: "0",
-            };
+        log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start));
+        return uniqueNames;
+    }
 
+    function getStringLiteralCompletionEntries(sourceFile: SourceFile, position: number, typeChecker: TypeChecker, compilerOptions: CompilerOptions, host: LanguageServiceHost, log: Log): CompletionInfo | undefined {
+        const node = findPrecedingToken(position, sourceFile);
+        if (!node || node.kind !== SyntaxKind.StringLiteral) {
+            return undefined;
         }
 
-        function getCompletionEntriesFromSymbols(symbols: Symbol[], entries: CompletionEntry[], location: Node, performCharacterChecks: boolean): Map<string> {
-            const start = timestamp();
-            const uniqueNames = createMap<string>();
-            if (symbols) {
-                for (const symbol of symbols) {
-                    const entry = createCompletionEntry(symbol, location, performCharacterChecks);
-                    if (entry) {
-                        const id = escapeIdentifier(entry.name);
-                        if (!uniqueNames[id]) {
-                            entries.push(entry);
-                            uniqueNames[id] = id;
-                        }
-                    }
-                }
-            }
-
-            log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start));
-            return uniqueNames;
+        if (node.parent.kind === SyntaxKind.PropertyAssignment &&
+            node.parent.parent.kind === SyntaxKind.ObjectLiteralExpression &&
+            (<PropertyAssignment>node.parent).name === node) {
+            // Get quoted name of properties of the object literal expression
+            // i.e. interface ConfigFiles {
+            //          'jspm:dev': string
+            //      }
+            //      let files: ConfigFiles = {
+            //          '/*completion position*/'
+            //      }
+            //
+            //      function foo(c: ConfigFiles) {}
+            //      foo({
+            //          '/*completion position*/'
+            //      });
+            return getStringLiteralCompletionEntriesFromPropertyAssignment(<ObjectLiteralElement>node.parent, typeChecker, compilerOptions.target, log);
         }
-
-        function getStringLiteralCompletionEntries(sourceFile: SourceFile, position: number): CompletionInfo | undefined {
-            const node = findPrecedingToken(position, sourceFile);
-            if (!node || node.kind !== SyntaxKind.StringLiteral) {
-                return undefined;
-            }
-
-            if (node.parent.kind === SyntaxKind.PropertyAssignment &&
-                node.parent.parent.kind === SyntaxKind.ObjectLiteralExpression &&
-                (<PropertyAssignment>node.parent).name === node) {
-                // Get quoted name of properties of the object literal expression
-                // i.e. interface ConfigFiles {
-                //          'jspm:dev': string
-                //      }
-                //      let files: ConfigFiles = {
-                //          '/*completion position*/'
-                //      }
-                //
-                //      function foo(c: ConfigFiles) {}
-                //      foo({
-                //          '/*completion position*/'
-                //      });
-                return getStringLiteralCompletionEntriesFromPropertyAssignment(<ObjectLiteralElement>node.parent);
-            }
-            else if (isElementAccessExpression(node.parent) && node.parent.argumentExpression === node) {
-                // Get all names of properties on the expression
-                // i.e. interface A {
-                //      'prop1': string
-                // }
-                // let a: A;
-                // a['/*completion position*/']
-                return getStringLiteralCompletionEntriesFromElementAccess(node.parent);
-            }
-            else if (node.parent.kind === SyntaxKind.ImportDeclaration || isExpressionOfExternalModuleImportEqualsDeclaration(node) || isRequireCall(node.parent, false)) {
-                // Get all known external module names or complete a path to a module
-                // i.e. import * as ns from "/*completion position*/";
-                //      import x = require("/*completion position*/");
-                //      var y = require("/*completion position*/");
-                return getStringLiteralCompletionEntriesFromModuleNames(<StringLiteral>node);
-            }
-            else {
-                const argumentInfo = SignatureHelp.getImmediatelyContainingArgumentInfo(node, position, sourceFile);
-                if (argumentInfo) {
-                    // Get string literal completions from specialized signatures of the target
-                    // i.e. declare function f(a: 'A');
-                    // f("/*completion position*/")
-                    return getStringLiteralCompletionEntriesFromCallExpression(argumentInfo);
-                }
-
-                // Get completion for string literal from string literal type
-                // i.e. var x: "hi" | "hello" = "/*completion position*/"
-                return getStringLiteralCompletionEntriesFromContextualType(<StringLiteral>node);
-            }
+        else if (isElementAccessExpression(node.parent) && node.parent.argumentExpression === node) {
+            // Get all names of properties on the expression
+            // i.e. interface A {
+            //      'prop1': string
+            // }
+            // let a: A;
+            // a['/*completion position*/']
+            return getStringLiteralCompletionEntriesFromElementAccess(node.parent, typeChecker, compilerOptions.target, log);
         }
-
-        function getStringLiteralCompletionEntriesFromPropertyAssignment(element: ObjectLiteralElement): CompletionInfo | undefined {
-            const type = typeChecker.getContextualType((<ObjectLiteralExpression>element.parent));
-            const entries: CompletionEntry[] = [];
-            if (type) {
-                getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, element, /*performCharacterChecks*/false);
-                if (entries.length) {
-                    return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };
-                }
-            }
+        else if (node.parent.kind === SyntaxKind.ImportDeclaration || isExpressionOfExternalModuleImportEqualsDeclaration(node) || isRequireCall(node.parent, false)) {
+            // Get all known external module names or complete a path to a module
+            // i.e. import * as ns from "/*completion position*/";
+            //      import x = require("/*completion position*/");
+            //      var y = require("/*completion position*/");
+            return getStringLiteralCompletionEntriesFromModuleNames(<StringLiteral>node, compilerOptions, host, typeChecker);
         }
-
-        function getStringLiteralCompletionEntriesFromCallExpression(argumentInfo: SignatureHelp.ArgumentListInfo): CompletionInfo | undefined {
-            const candidates: Signature[] = [];
-            const entries: CompletionEntry[] = [];
-
-            typeChecker.getResolvedSignature(argumentInfo.invocation, candidates);
-
-            for (const candidate of candidates) {
-                addStringLiteralCompletionsFromType(typeChecker.getParameterType(candidate, argumentInfo.argumentIndex), entries);
+        else {
+            const argumentInfo = SignatureHelp.getImmediatelyContainingArgumentInfo(node, position, sourceFile);
+            if (argumentInfo) {
+                // Get string literal completions from specialized signatures of the target
+                // i.e. declare function f(a: 'A');
+                // f("/*completion position*/")
+                return getStringLiteralCompletionEntriesFromCallExpression(argumentInfo, typeChecker);
             }
 
+            // Get completion for string literal from string literal type
+            // i.e. var x: "hi" | "hello" = "/*completion position*/"
+            return getStringLiteralCompletionEntriesFromContextualType(<StringLiteral>node, typeChecker);
+        }
+    }
+
+    function getStringLiteralCompletionEntriesFromPropertyAssignment(element: ObjectLiteralElement, typeChecker: TypeChecker, target: ScriptTarget, log: Log): CompletionInfo | undefined {
+        const type = typeChecker.getContextualType((<ObjectLiteralExpression>element.parent));
+        const entries: CompletionEntry[] = [];
+        if (type) {
+            getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, element, /*performCharacterChecks*/false, typeChecker, target, log);
             if (entries.length) {
-                return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: true, entries };
+                return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };
             }
+        }
+    }
 
-            return undefined;
+    function getStringLiteralCompletionEntriesFromCallExpression(argumentInfo: SignatureHelp.ArgumentListInfo, typeChecker: TypeChecker): CompletionInfo | undefined {
+        const candidates: Signature[] = [];
+        const entries: CompletionEntry[] = [];
+
+        typeChecker.getResolvedSignature(argumentInfo.invocation, candidates);
+
+        for (const candidate of candidates) {
+            addStringLiteralCompletionsFromType(typeChecker.getParameterType(candidate, argumentInfo.argumentIndex), entries, typeChecker);
         }
 
-        function getStringLiteralCompletionEntriesFromElementAccess(node: ElementAccessExpression): CompletionInfo | undefined {
-            const type = typeChecker.getTypeAtLocation(node.expression);
+        if (entries.length) {
+            return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: true, entries };
+        }
+
+        return undefined;
+    }
+
+    function getStringLiteralCompletionEntriesFromElementAccess(node: ElementAccessExpression, typeChecker: TypeChecker, target: ScriptTarget, log: Log): CompletionInfo | undefined {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const entries: CompletionEntry[] = [];
+        if (type) {
+            getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, node, /*performCharacterChecks*/false, typeChecker, target, log);
+            if (entries.length) {
+                return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };
+            }
+        }
+        return undefined;
+    }
+
+    function getStringLiteralCompletionEntriesFromContextualType(node: StringLiteral, typeChecker: TypeChecker): CompletionInfo | undefined {
+        const type = typeChecker.getContextualType(node);
+        if (type) {
             const entries: CompletionEntry[] = [];
-            if (type) {
-                getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, node, /*performCharacterChecks*/false);
-                if (entries.length) {
-                    return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };
-                }
-            }
-            return undefined;
-        }
-
-        function getStringLiteralCompletionEntriesFromContextualType(node: StringLiteral): CompletionInfo | undefined {
-            const type = typeChecker.getContextualType(node);
-            if (type) {
-                const entries: CompletionEntry[] = [];
-                addStringLiteralCompletionsFromType(type, entries);
-                if (entries.length) {
-                    return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
-                }
-            }
-            return undefined;
-        }
-
-        function addStringLiteralCompletionsFromType(type: Type, result: Push<CompletionEntry>): void {
-            if (type && type.flags & TypeFlags.TypeParameter) {
-                type = typeChecker.getApparentType(type);
-            }
-            if (!type) {
-                return;
-            }
-            if (type.flags & TypeFlags.Union) {
-                for (const t of (<UnionType>type).types) {
-                    addStringLiteralCompletionsFromType(t, result);
-                }
-            }
-            else if (type.flags & TypeFlags.StringLiteral) {
-                result.push({
-                    name: (<LiteralType>type).text,
-                    kindModifiers: ScriptElementKindModifier.none,
-                    kind: ScriptElementKind.variableElement,
-                    sortText: "0"
-                });
+            addStringLiteralCompletionsFromType(type, entries, typeChecker);
+            if (entries.length) {
+                return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
             }
         }
+        return undefined;
+    }
 
-        function getStringLiteralCompletionEntriesFromModuleNames(node: StringLiteral): CompletionInfo {
-            const literalValue = normalizeSlashes(node.text);
+    function addStringLiteralCompletionsFromType(type: Type, result: Push<CompletionEntry>, typeChecker: TypeChecker): void {
+        if (type && type.flags & TypeFlags.TypeParameter) {
+            type = typeChecker.getApparentType(type);
+        }
+        if (!type) {
+            return;
+        }
+        if (type.flags & TypeFlags.Union) {
+            for (const t of (<UnionType>type).types) {
+                addStringLiteralCompletionsFromType(t, result, typeChecker);
+            }
+        }
+        else if (type.flags & TypeFlags.StringLiteral) {
+            result.push({
+                name: (<LiteralType>type).text,
+                kindModifiers: ScriptElementKindModifier.none,
+                kind: ScriptElementKind.variableElement,
+                sortText: "0"
+            });
+        }
+    }
 
-            const scriptPath = node.getSourceFile().path;
-            const scriptDirectory = getDirectoryPath(scriptPath);
+    function getStringLiteralCompletionEntriesFromModuleNames(node: StringLiteral, compilerOptions: CompilerOptions, host: LanguageServiceHost, typeChecker: TypeChecker): CompletionInfo {
+        const literalValue = normalizeSlashes(node.text);
 
-            const span = getDirectoryFragmentTextSpan((<StringLiteral>node).text, node.getStart() + 1);
-            let entries: CompletionEntry[];
-            if (isPathRelativeToScript(literalValue) || isRootedDiskPath(literalValue)) {
-                if (compilerOptions.rootDirs) {
-                    entries = getCompletionEntriesForDirectoryFragmentWithRootDirs(
-                        compilerOptions.rootDirs, literalValue, scriptDirectory, getSupportedExtensions(compilerOptions), /*includeExtensions*/false, span, scriptPath);
-                }
-                else {
-                    entries = getCompletionEntriesForDirectoryFragment(
-                        literalValue, scriptDirectory, getSupportedExtensions(compilerOptions), /*includeExtensions*/false, span, scriptPath);
-                }
+        const scriptPath = node.getSourceFile().path;
+        const scriptDirectory = getDirectoryPath(scriptPath);
+
+        const span = getDirectoryFragmentTextSpan((<StringLiteral>node).text, node.getStart() + 1);
+        let entries: CompletionEntry[];
+        if (isPathRelativeToScript(literalValue) || isRootedDiskPath(literalValue)) {
+            const extensions = getSupportedExtensions(compilerOptions);
+            if (compilerOptions.rootDirs) {
+                entries = getCompletionEntriesForDirectoryFragmentWithRootDirs(
+                    compilerOptions.rootDirs, literalValue, scriptDirectory, extensions, /*includeExtensions*/false, span, compilerOptions, host, scriptPath);
             }
             else {
-                // Check for node modules
-                entries = getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, span);
+                entries = getCompletionEntriesForDirectoryFragment(
+                    literalValue, scriptDirectory, extensions, /*includeExtensions*/false, span, host, scriptPath);
             }
-            return {
-                isGlobalCompletion: false,
-                isMemberCompletion: false,
-                isNewIdentifierLocation: true,
-                entries
-            };
         }
+        else {
+            // Check for node modules
+            entries = getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, span, compilerOptions, host, typeChecker);
+        }
+        return {
+            isGlobalCompletion: false,
+            isMemberCompletion: false,
+            isNewIdentifierLocation: true,
+            entries
+        };
+    }
+
+    /**
+     * Takes a script path and returns paths for all potential folders that could be merged with its
+     * containing folder via the "rootDirs" compiler option
+     */
+    function getBaseDirectoriesFromRootDirs(rootDirs: string[], basePath: string, scriptPath: string, ignoreCase: boolean): string[] {
+        // Make all paths absolute/normalized if they are not already
+        rootDirs = map(rootDirs, rootDirectory => normalizePath(isRootedDiskPath(rootDirectory) ? rootDirectory : combinePaths(basePath, rootDirectory)));
+
+        // Determine the path to the directory containing the script relative to the root directory it is contained within
+        let relativeDirectory: string;
+        for (const rootDirectory of rootDirs) {
+            if (containsPath(rootDirectory, scriptPath, basePath, ignoreCase)) {
+                relativeDirectory = scriptPath.substr(rootDirectory.length);
+                break;
+            }
+        }
+
+        // Now find a path for each potential directory that is to be merged with the one containing the script
+        return deduplicate(map(rootDirs, rootDirectory => combinePaths(rootDirectory, relativeDirectory)));
+    }
+
+    function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs: string[], fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean, span: TextSpan, compilerOptions: CompilerOptions, host: LanguageServiceHost, exclude?: string): CompletionEntry[] {
+        const basePath = compilerOptions.project || host.getCurrentDirectory();
+        const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
+        const baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptPath, ignoreCase);
+
+        const result: CompletionEntry[] = [];
+
+        for (const baseDirectory of baseDirectories) {
+            getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensions, includeExtensions, span, host, exclude, result);
+        }
+
+        return result;
+    }
+
+    /**
+     * Given a path ending at a directory, gets the completions for the path, and filters for those entries containing the basename.
+     */
+    function getCompletionEntriesForDirectoryFragment(fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean, span: TextSpan, host: LanguageServiceHost, exclude?: string, result: CompletionEntry[] = []): CompletionEntry[] {
+        if (fragment === undefined) {
+            fragment = "";
+        }
+
+        fragment = normalizeSlashes(fragment);
 
         /**
-         * Takes a script path and returns paths for all potential folders that could be merged with its
-         * containing folder via the "rootDirs" compiler option
+         * Remove the basename from the path. Note that we don't use the basename to filter completions;
+         * the client is responsible for refining completions.
          */
-        function getBaseDirectoriesFromRootDirs(rootDirs: string[], basePath: string, scriptPath: string, ignoreCase: boolean): string[] {
-            // Make all paths absolute/normalized if they are not already
-            rootDirs = map(rootDirs, rootDirectory => normalizePath(isRootedDiskPath(rootDirectory) ? rootDirectory : combinePaths(basePath, rootDirectory)));
+        fragment = getDirectoryPath(fragment);
 
-            // Determine the path to the directory containing the script relative to the root directory it is contained within
-            let relativeDirectory: string;
-            for (const rootDirectory of rootDirs) {
-                if (containsPath(rootDirectory, scriptPath, basePath, ignoreCase)) {
-                    relativeDirectory = scriptPath.substr(rootDirectory.length);
-                    break;
-                }
-            }
-
-            // Now find a path for each potential directory that is to be merged with the one containing the script
-            return deduplicate(map(rootDirs, rootDirectory => combinePaths(rootDirectory, relativeDirectory)));
+        if (fragment === "") {
+            fragment = "." + directorySeparator;
         }
 
-        function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs: string[], fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean, span: TextSpan, exclude?: string): CompletionEntry[] {
-            const basePath = compilerOptions.project || host.getCurrentDirectory();
-            const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
-            const baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptPath, ignoreCase);
+        fragment = ensureTrailingDirectorySeparator(fragment);
 
-            const result: CompletionEntry[] = [];
+        const absolutePath = normalizeAndPreserveTrailingSlash(isRootedDiskPath(fragment) ? fragment : combinePaths(scriptPath, fragment));
+        const baseDirectory = getDirectoryPath(absolutePath);
+        const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
 
-            for (const baseDirectory of baseDirectories) {
-                getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensions, includeExtensions, span, exclude, result);
-            }
+        if (tryDirectoryExists(host, baseDirectory)) {
+            // Enumerate the available files if possible
+            const files = tryReadDirectory(host, baseDirectory, extensions, /*exclude*/undefined, /*include*/["./*"]);
 
-            return result;
-        }
-
-        /**
-         * Given a path ending at a directory, gets the completions for the path, and filters for those entries containing the basename.
-         */
-        function getCompletionEntriesForDirectoryFragment(fragment: string, scriptPath: string, extensions: string[], includeExtensions: boolean, span: TextSpan, exclude?: string, result: CompletionEntry[] = []): CompletionEntry[] {
-            if (fragment === undefined) {
-                fragment = "";
-            }
-
-            fragment = normalizeSlashes(fragment);
-
-            /**
-             * Remove the basename from the path. Note that we don't use the basename to filter completions;
-             * the client is responsible for refining completions.
-             */
-            fragment = getDirectoryPath(fragment);
-
-            if (fragment === "") {
-                fragment = "." + directorySeparator;
-            }
-
-            fragment = ensureTrailingDirectorySeparator(fragment);
-
-            const absolutePath = normalizeAndPreserveTrailingSlash(isRootedDiskPath(fragment) ? fragment : combinePaths(scriptPath, fragment));
-            const baseDirectory = getDirectoryPath(absolutePath);
-            const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
-
-            if (tryDirectoryExists(host, baseDirectory)) {
-                // Enumerate the available files if possible
-                const files = tryReadDirectory(host, baseDirectory, extensions, /*exclude*/undefined, /*include*/["./*"]);
-
-                if (files) {
-                    /**
-                     * Multiple file entries might map to the same truncated name once we remove extensions
-                     * (happens iff includeExtensions === false)so we use a set-like data structure. Eg:
-                     *
-                     * both foo.ts and foo.tsx become foo
-                     */
-                    const foundFiles = createMap<boolean>();
-                    for (let filePath of files) {
-                        filePath = normalizePath(filePath);
-                        if (exclude && comparePaths(filePath, exclude, scriptPath, ignoreCase) === Comparison.EqualTo) {
-                            continue;
-                        }
-
-                        const foundFileName = includeExtensions ? getBaseFileName(filePath) : removeFileExtension(getBaseFileName(filePath));
-
-                        if (!foundFiles[foundFileName]) {
-                            foundFiles[foundFileName] = true;
-                        }
+            if (files) {
+                /**
+                 * Multiple file entries might map to the same truncated name once we remove extensions
+                 * (happens iff includeExtensions === false)so we use a set-like data structure. Eg:
+                 *
+                 * both foo.ts and foo.tsx become foo
+                 */
+                const foundFiles = createMap<boolean>();
+                for (let filePath of files) {
+                    filePath = normalizePath(filePath);
+                    if (exclude && comparePaths(filePath, exclude, scriptPath, ignoreCase) === Comparison.EqualTo) {
+                        continue;
                     }
 
-                    for (const foundFile in foundFiles) {
-                        result.push(createCompletionEntryForModule(foundFile, ScriptElementKind.scriptElement, span));
+                    const foundFileName = includeExtensions ? getBaseFileName(filePath) : removeFileExtension(getBaseFileName(filePath));
+
+                    if (!foundFiles[foundFileName]) {
+                        foundFiles[foundFileName] = true;
                     }
                 }
 
-                // If possible, get folder completion as well
-                const directories = tryGetDirectories(host, baseDirectory);
-
-                if (directories) {
-                    for (const directory of directories) {
-                        const directoryName = getBaseFileName(normalizePath(directory));
-
-                        result.push(createCompletionEntryForModule(directoryName, ScriptElementKind.directory, span));
-                    }
+                for (const foundFile in foundFiles) {
+                    result.push(createCompletionEntryForModule(foundFile, ScriptElementKind.scriptElement, span));
                 }
             }
 
-            return result;
+            // If possible, get folder completion as well
+            const directories = tryGetDirectories(host, baseDirectory);
+
+            if (directories) {
+                for (const directory of directories) {
+                    const directoryName = getBaseFileName(normalizePath(directory));
+
+                    result.push(createCompletionEntryForModule(directoryName, ScriptElementKind.directory, span));
+                }
+            }
         }
 
-        /**
-         * Check all of the declared modules and those in node modules. Possible sources of modules:
-         *      Modules that are found by the type checker
-         *      Modules found relative to "baseUrl" compliler options (including patterns from "paths" compiler option)
-         *      Modules from node_modules (i.e. those listed in package.json)
-         *          This includes all files that are found in node_modules/moduleName/ with acceptable file extensions
-         */
-        function getCompletionEntriesForNonRelativeModules(fragment: string, scriptPath: string, span: TextSpan): CompletionEntry[] {
-            const { baseUrl, paths } = compilerOptions;
+        return result;
+    }
 
-            let result: CompletionEntry[];
+    /**
+     * Check all of the declared modules and those in node modules. Possible sources of modules:
+     *      Modules that are found by the type checker
+     *      Modules found relative to "baseUrl" compliler options (including patterns from "paths" compiler option)
+     *      Modules from node_modules (i.e. those listed in package.json)
+     *          This includes all files that are found in node_modules/moduleName/ with acceptable file extensions
+     */
+    function getCompletionEntriesForNonRelativeModules(fragment: string, scriptPath: string, span: TextSpan, compilerOptions: CompilerOptions, host: LanguageServiceHost, typeChecker: TypeChecker): CompletionEntry[] {
+        const { baseUrl, paths } = compilerOptions;
 
-            if (baseUrl) {
-                const fileExtensions = getSupportedExtensions(compilerOptions);
-                const projectDir = compilerOptions.project || host.getCurrentDirectory();
-                const absolute = isRootedDiskPath(baseUrl) ? baseUrl : combinePaths(projectDir, baseUrl);
-                result = getCompletionEntriesForDirectoryFragment(fragment, normalizePath(absolute), fileExtensions, /*includeExtensions*/false, span);
+        let result: CompletionEntry[];
 
-                if (paths) {
-                    for (const path in paths) {
-                        if (paths.hasOwnProperty(path)) {
-                            if (path === "*") {
-                                if (paths[path]) {
-                                    for (const pattern of paths[path]) {
-                                        for (const match of getModulesForPathsPattern(fragment, baseUrl, pattern, fileExtensions)) {
-                                            result.push(createCompletionEntryForModule(match, ScriptElementKind.externalModuleName, span));
-                                        }
+        if (baseUrl) {
+            const fileExtensions = getSupportedExtensions(compilerOptions);
+            const projectDir = compilerOptions.project || host.getCurrentDirectory();
+            const absolute = isRootedDiskPath(baseUrl) ? baseUrl : combinePaths(projectDir, baseUrl);
+            result = getCompletionEntriesForDirectoryFragment(fragment, normalizePath(absolute), fileExtensions, /*includeExtensions*/false, span, host);
+
+            if (paths) {
+                for (const path in paths) {
+                    if (paths.hasOwnProperty(path)) {
+                        if (path === "*") {
+                            if (paths[path]) {
+                                for (const pattern of paths[path]) {
+                                    for (const match of getModulesForPathsPattern(fragment, baseUrl, pattern, fileExtensions, host)) {
+                                        result.push(createCompletionEntryForModule(match, ScriptElementKind.externalModuleName, span));
                                     }
                                 }
                             }
-                            else if (startsWith(path, fragment)) {
-                                const entry = paths[path] && paths[path].length === 1 && paths[path][0];
-                                if (entry) {
-                                    result.push(createCompletionEntryForModule(path, ScriptElementKind.externalModuleName, span));
-                                }
+                        }
+                        else if (startsWith(path, fragment)) {
+                            const entry = paths[path] && paths[path].length === 1 && paths[path][0];
+                            if (entry) {
+                                result.push(createCompletionEntryForModule(path, ScriptElementKind.externalModuleName, span));
                             }
                         }
                     }
                 }
             }
-            else {
-                result = [];
-            }
-
-            getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, span, result);
-
-            for (const moduleName of enumeratePotentialNonRelativeModules(fragment, scriptPath, compilerOptions)) {
-                result.push(createCompletionEntryForModule(moduleName, ScriptElementKind.externalModuleName, span));
-            }
-
-            return result;
+        }
+        else {
+            result = [];
         }
 
-        function getModulesForPathsPattern(fragment: string, baseUrl: string, pattern: string, fileExtensions: string[]): string[] {
-            if (host.readDirectory) {
-                const parsed = hasZeroOrOneAsteriskCharacter(pattern) ? tryParsePattern(pattern) : undefined;
-                if (parsed) {
-                    // The prefix has two effective parts: the directory path and the base component after the filepath that is not a
-                    // full directory component. For example: directory/path/of/prefix/base*
-                    const normalizedPrefix = normalizeAndPreserveTrailingSlash(parsed.prefix);
-                    const normalizedPrefixDirectory = getDirectoryPath(normalizedPrefix);
-                    const normalizedPrefixBase = getBaseFileName(normalizedPrefix);
+        getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, span, result);
 
-                    const fragmentHasPath = fragment.indexOf(directorySeparator) !== -1;
+        for (const moduleName of enumeratePotentialNonRelativeModules(fragment, scriptPath, compilerOptions, typeChecker, host)) {
+            result.push(createCompletionEntryForModule(moduleName, ScriptElementKind.externalModuleName, span));
+        }
 
-                    // Try and expand the prefix to include any path from the fragment so that we can limit the readDirectory call
-                    const expandedPrefixDirectory = fragmentHasPath ? combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + getDirectoryPath(fragment)) : normalizedPrefixDirectory;
+        return result;
+    }
 
-                    const normalizedSuffix = normalizePath(parsed.suffix);
-                    const baseDirectory = combinePaths(baseUrl, expandedPrefixDirectory);
-                    const completePrefix = fragmentHasPath ? baseDirectory : ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase;
+    function getModulesForPathsPattern(fragment: string, baseUrl: string, pattern: string, fileExtensions: string[], host: LanguageServiceHost): string[] {
+        if (host.readDirectory) {
+            const parsed = hasZeroOrOneAsteriskCharacter(pattern) ? tryParsePattern(pattern) : undefined;
+            if (parsed) {
+                // The prefix has two effective parts: the directory path and the base component after the filepath that is not a
+                // full directory component. For example: directory/path/of/prefix/base*
+                const normalizedPrefix = normalizeAndPreserveTrailingSlash(parsed.prefix);
+                const normalizedPrefixDirectory = getDirectoryPath(normalizedPrefix);
+                const normalizedPrefixBase = getBaseFileName(normalizedPrefix);
 
-                    // If we have a suffix, then we need to read the directory all the way down. We could create a glob
-                    // that encodes the suffix, but we would have to escape the character "?" which readDirectory
-                    // doesn't support. For now, this is safer but slower
-                    const includeGlob = normalizedSuffix ? "**/*" : "./*";
+                const fragmentHasPath = fragment.indexOf(directorySeparator) !== -1;
 
-                    const matches = tryReadDirectory(host, baseDirectory, fileExtensions, undefined, [includeGlob]);
-                    if (matches) {
-                        const result: string[] = [];
+                // Try and expand the prefix to include any path from the fragment so that we can limit the readDirectory call
+                const expandedPrefixDirectory = fragmentHasPath ? combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + getDirectoryPath(fragment)) : normalizedPrefixDirectory;
 
-                        // Trim away prefix and suffix
-                        for (const match of matches) {
-                            const normalizedMatch = normalizePath(match);
-                            if (!endsWith(normalizedMatch, normalizedSuffix) || !startsWith(normalizedMatch, completePrefix)) {
-                                continue;
-                            }
+                const normalizedSuffix = normalizePath(parsed.suffix);
+                const baseDirectory = combinePaths(baseUrl, expandedPrefixDirectory);
+                const completePrefix = fragmentHasPath ? baseDirectory : ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase;
 
-                            const start = completePrefix.length;
-                            const length = normalizedMatch.length - start - normalizedSuffix.length;
+                // If we have a suffix, then we need to read the directory all the way down. We could create a glob
+                // that encodes the suffix, but we would have to escape the character "?" which readDirectory
+                // doesn't support. For now, this is safer but slower
+                const includeGlob = normalizedSuffix ? "**/*" : "./*";
 
-                            result.push(removeFileExtension(normalizedMatch.substr(start, length)));
+                const matches = tryReadDirectory(host, baseDirectory, fileExtensions, undefined, [includeGlob]);
+                if (matches) {
+                    const result: string[] = [];
+
+                    // Trim away prefix and suffix
+                    for (const match of matches) {
+                        const normalizedMatch = normalizePath(match);
+                        if (!endsWith(normalizedMatch, normalizedSuffix) || !startsWith(normalizedMatch, completePrefix)) {
+                            continue;
+                        }
+
+                        const start = completePrefix.length;
+                        const length = normalizedMatch.length - start - normalizedSuffix.length;
+
+                        result.push(removeFileExtension(normalizedMatch.substr(start, length)));
+                    }
+                    return result;
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    function enumeratePotentialNonRelativeModules(fragment: string, scriptPath: string, options: CompilerOptions, typeChecker: TypeChecker, host: LanguageServiceHost): string[] {
+        // Check If this is a nested module
+        const isNestedModule = fragment.indexOf(directorySeparator) !== -1;
+        const moduleNameFragment = isNestedModule ? fragment.substr(0, fragment.lastIndexOf(directorySeparator)) : undefined;
+
+        // Get modules that the type checker picked up
+        const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.name));
+        let nonRelativeModules = filter(ambientModules, moduleName => startsWith(moduleName, fragment));
+
+        // Nested modules of the form "module-name/sub" need to be adjusted to only return the string
+        // after the last '/' that appears in the fragment because that's where the replacement span
+        // starts
+        if (isNestedModule) {
+            const moduleNameWithSeperator = ensureTrailingDirectorySeparator(moduleNameFragment);
+            nonRelativeModules = map(nonRelativeModules, moduleName => {
+                if (startsWith(fragment, moduleNameWithSeperator)) {
+                    return moduleName.substr(moduleNameWithSeperator.length);
+                }
+                return moduleName;
+            });
+        }
+
+
+        if (!options.moduleResolution || options.moduleResolution === ModuleResolutionKind.NodeJs) {
+            for (const visibleModule of enumerateNodeModulesVisibleToScript(host, scriptPath)) {
+                if (!isNestedModule) {
+                    nonRelativeModules.push(visibleModule.moduleName);
+                }
+                else if (startsWith(visibleModule.moduleName, moduleNameFragment)) {
+                    const nestedFiles = tryReadDirectory(host, visibleModule.moduleDir, supportedTypeScriptExtensions, /*exclude*/undefined, /*include*/["./*"]);
+                    if (nestedFiles) {
+                        for (let f of nestedFiles) {
+                            f = normalizePath(f);
+                            const nestedModule = removeFileExtension(getBaseFileName(f));
+                            nonRelativeModules.push(nestedModule);
                         }
-                        return result;
                     }
                 }
             }
+        }
 
+        return deduplicate(nonRelativeModules);
+    }
+
+    function getTripleSlashReferenceCompletion(sourceFile: SourceFile, position: number, compilerOptions: CompilerOptions, host: LanguageServiceHost): CompletionInfo {
+        const token = getTokenAtPosition(sourceFile, position);
+        if (!token) {
+            return undefined;
+        }
+        const commentRanges: CommentRange[] = getLeadingCommentRanges(sourceFile.text, token.pos);
+
+        if (!commentRanges || !commentRanges.length) {
             return undefined;
         }
 
-        function enumeratePotentialNonRelativeModules(fragment: string, scriptPath: string, options: CompilerOptions): string[] {
-            // Check If this is a nested module
-            const isNestedModule = fragment.indexOf(directorySeparator) !== -1;
-            const moduleNameFragment = isNestedModule ? fragment.substr(0, fragment.lastIndexOf(directorySeparator)) : undefined;
+        const range = forEach(commentRanges, commentRange => position >= commentRange.pos && position <= commentRange.end && commentRange);
 
-            // Get modules that the type checker picked up
-            const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.name));
-            let nonRelativeModules = filter(ambientModules, moduleName => startsWith(moduleName, fragment));
-
-            // Nested modules of the form "module-name/sub" need to be adjusted to only return the string
-            // after the last '/' that appears in the fragment because that's where the replacement span
-            // starts
-            if (isNestedModule) {
-                const moduleNameWithSeperator = ensureTrailingDirectorySeparator(moduleNameFragment);
-                nonRelativeModules = map(nonRelativeModules, moduleName => {
-                    if (startsWith(fragment, moduleNameWithSeperator)) {
-                        return moduleName.substr(moduleNameWithSeperator.length);
-                    }
-                    return moduleName;
-                });
-            }
-
-
-            if (!options.moduleResolution || options.moduleResolution === ModuleResolutionKind.NodeJs) {
-                for (const visibleModule of enumerateNodeModulesVisibleToScript(host, scriptPath)) {
-                    if (!isNestedModule) {
-                        nonRelativeModules.push(visibleModule.moduleName);
-                    }
-                    else if (startsWith(visibleModule.moduleName, moduleNameFragment)) {
-                        const nestedFiles = tryReadDirectory(host, visibleModule.moduleDir, supportedTypeScriptExtensions, /*exclude*/undefined, /*include*/["./*"]);
-                        if (nestedFiles) {
-                            for (let f of nestedFiles) {
-                                f = normalizePath(f);
-                                const nestedModule = removeFileExtension(getBaseFileName(f));
-                                nonRelativeModules.push(nestedModule);
-                            }
-                        }
-                    }
-                }
-            }
-
-            return deduplicate(nonRelativeModules);
+        if (!range) {
+            return undefined;
         }
 
-        function getTripleSlashReferenceCompletion(sourceFile: SourceFile, position: number): CompletionInfo {
-            const token = getTokenAtPosition(sourceFile, position);
-            if (!token) {
-                return undefined;
+        const completionInfo: CompletionInfo = {
+            /**
+             * We don't want the editor to offer any other completions, such as snippets, inside a comment.
+             */
+            isGlobalCompletion: false,
+            isMemberCompletion: false,
+            /**
+             * The user may type in a path that doesn't yet exist, creating a "new identifier"
+             * with respect to the collection of identifiers the server is aware of.
+             */
+            isNewIdentifierLocation: true,
+
+            entries: []
+        };
+
+        const text = sourceFile.text.substr(range.pos, position - range.pos);
+
+        const match = tripleSlashDirectiveFragmentRegex.exec(text);
+
+        if (match) {
+            const prefix = match[1];
+            const kind = match[2];
+            const toComplete = match[3];
+
+            const scriptPath = getDirectoryPath(sourceFile.path);
+            if (kind === "path") {
+                // Give completions for a relative path
+                const span: TextSpan = getDirectoryFragmentTextSpan(toComplete, range.pos + prefix.length);
+                completionInfo.entries = getCompletionEntriesForDirectoryFragment(toComplete, scriptPath, getSupportedExtensions(compilerOptions), /*includeExtensions*/true, span, host, sourceFile.path);
             }
-            const commentRanges: CommentRange[] = getLeadingCommentRanges(sourceFile.text, token.pos);
-
-            if (!commentRanges || !commentRanges.length) {
-                return undefined;
+            else {
+                // Give completions based on the typings available
+                const span: TextSpan = { start: range.pos + prefix.length, length: match[0].length - prefix.length };
+                completionInfo.entries = getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, span);
             }
-
-            const range = forEach(commentRanges, commentRange => position >= commentRange.pos && position <= commentRange.end && commentRange);
-
-            if (!range) {
-                return undefined;
-            }
-
-            const completionInfo: CompletionInfo = {
-                /**
-                 * We don't want the editor to offer any other completions, such as snippets, inside a comment.
-                 */
-                isGlobalCompletion: false,
-                isMemberCompletion: false,
-                /**
-                 * The user may type in a path that doesn't yet exist, creating a "new identifier"
-                 * with respect to the collection of identifiers the server is aware of.
-                 */
-                isNewIdentifierLocation: true,
-
-                entries: []
-            };
-
-            const text = sourceFile.text.substr(range.pos, position - range.pos);
-
-            const match = tripleSlashDirectiveFragmentRegex.exec(text);
-
-            if (match) {
-                const prefix = match[1];
-                const kind = match[2];
-                const toComplete = match[3];
-
-                const scriptPath = getDirectoryPath(sourceFile.path);
-                if (kind === "path") {
-                    // Give completions for a relative path
-                    const span: TextSpan = getDirectoryFragmentTextSpan(toComplete, range.pos + prefix.length);
-                    completionInfo.entries = getCompletionEntriesForDirectoryFragment(toComplete, scriptPath, getSupportedExtensions(compilerOptions), /*includeExtensions*/true, span, sourceFile.path);
-                }
-                else {
-                    // Give completions based on the typings available
-                    const span: TextSpan = { start: range.pos + prefix.length, length: match[0].length - prefix.length };
-                    completionInfo.entries = getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, span);
-                }
-            }
-
-            return completionInfo;
         }
 
-        function getCompletionEntriesFromTypings(host: LanguageServiceHost, options: CompilerOptions, scriptPath: string, span: TextSpan, result: CompletionEntry[] = []): CompletionEntry[] {
-            // Check for typings specified in compiler options
-            if (options.types) {
-                for (const moduleName of options.types) {
-                    result.push(createCompletionEntryForModule(moduleName, ScriptElementKind.externalModuleName, span));
-                }
-            }
-            else if (host.getDirectories) {
-                let typeRoots: string[];
-                try {
-                    // Wrap in try catch because getEffectiveTypeRoots touches the filesystem
-                    typeRoots = getEffectiveTypeRoots(options, host);
-                }
-                catch (e) {}
+        return completionInfo;
+    }
 
-                if (typeRoots) {
-                    for (const root of typeRoots) {
-                        getCompletionEntriesFromDirectories(host, root, span, result);
-                    }
-                }
+    function getCompletionEntriesFromTypings(host: LanguageServiceHost, options: CompilerOptions, scriptPath: string, span: TextSpan, result: CompletionEntry[] = []): CompletionEntry[] {
+        // Check for typings specified in compiler options
+        if (options.types) {
+            for (const moduleName of options.types) {
+                result.push(createCompletionEntryForModule(moduleName, ScriptElementKind.externalModuleName, span));
             }
-
-            if (host.getDirectories) {
-                // Also get all @types typings installed in visible node_modules directories
-                for (const packageJson of findPackageJsons(scriptPath)) {
-                    const typesDir = combinePaths(getDirectoryPath(packageJson), "node_modules/@types");
-                    getCompletionEntriesFromDirectories(host, typesDir, span, result);
-                }
-            }
-
-            return result;
         }
+        else if (host.getDirectories) {
+            let typeRoots: string[];
+            try {
+                // Wrap in try catch because getEffectiveTypeRoots touches the filesystem
+                typeRoots = getEffectiveTypeRoots(options, host);
+            }
+            catch (e) {}
 
-        function getCompletionEntriesFromDirectories(host: LanguageServiceHost, directory: string, span: TextSpan, result: CompletionEntry[]) {
-            if (host.getDirectories && tryDirectoryExists(host, directory)) {
-                const directories = tryGetDirectories(host, directory);
-                if (directories) {
-                    for (let typeDirectory of directories) {
-                        typeDirectory = normalizePath(typeDirectory);
-                        result.push(createCompletionEntryForModule(getBaseFileName(typeDirectory), ScriptElementKind.externalModuleName, span));
-                    }
+            if (typeRoots) {
+                for (const root of typeRoots) {
+                    getCompletionEntriesFromDirectories(host, root, span, result);
                 }
             }
         }
 
-        function findPackageJsons(currentDir: string): string[] {
-            const paths: string[] = [];
-            let currentConfigPath: string;
-            while (true) {
-                currentConfigPath = findConfigFile(currentDir, (f) => tryFileExists(host, f), "package.json");
-                if (currentConfigPath) {
-                    paths.push(currentConfigPath);
+        if (host.getDirectories) {
+            // Also get all @types typings installed in visible node_modules directories
+            for (const packageJson of findPackageJsons(scriptPath, host)) {
+                const typesDir = combinePaths(getDirectoryPath(packageJson), "node_modules/@types");
+                getCompletionEntriesFromDirectories(host, typesDir, span, result);
+            }
+        }
 
-                    currentDir = getDirectoryPath(currentConfigPath);
-                    const parent = getDirectoryPath(currentDir);
-                    if (currentDir === parent) {
-                        break;
-                    }
-                    currentDir = parent;
+        return result;
+    }
+
+    function getCompletionEntriesFromDirectories(host: LanguageServiceHost, directory: string, span: TextSpan, result: Push<CompletionEntry>) {
+        if (host.getDirectories && tryDirectoryExists(host, directory)) {
+            const directories = tryGetDirectories(host, directory);
+            if (directories) {
+                for (let typeDirectory of directories) {
+                    typeDirectory = normalizePath(typeDirectory);
+                    result.push(createCompletionEntryForModule(getBaseFileName(typeDirectory), ScriptElementKind.externalModuleName, span));
                 }
-                else {
+            }
+        }
+    }
+
+    function findPackageJsons(currentDir: string, host: LanguageServiceHost): string[] {
+        const paths: string[] = [];
+        let currentConfigPath: string;
+        while (true) {
+            currentConfigPath = findConfigFile(currentDir, (f) => tryFileExists(host, f), "package.json");
+            if (currentConfigPath) {
+                paths.push(currentConfigPath);
+
+                currentDir = getDirectoryPath(currentConfigPath);
+                const parent = getDirectoryPath(currentDir);
+                if (currentDir === parent) {
                     break;
                 }
+                currentDir = parent;
+            }
+            else {
+                break;
             }
-
-            return paths;
         }
 
+        return paths;
+    }
 
-        function enumerateNodeModulesVisibleToScript(host: LanguageServiceHost, scriptPath: string) {
-            const result: VisibleModuleInfo[] = [];
+    function enumerateNodeModulesVisibleToScript(host: LanguageServiceHost, scriptPath: string) {
+        const result: VisibleModuleInfo[] = [];
 
-            if (host.readFile && host.fileExists) {
-                for (const packageJson of findPackageJsons(scriptPath)) {
-                    const contents = tryReadingPackageJson(packageJson);
-                    if (!contents) {
-                        return;
-                    }
-
-                    const nodeModulesDir = combinePaths(getDirectoryPath(packageJson), "node_modules");
-                    const foundModuleNames: string[] = [];
-
-                    // Provide completions for all non @types dependencies
-                    for (const key of nodeModulesDependencyKeys) {
-                        addPotentialPackageNames(contents[key], foundModuleNames);
-                    }
-
-                    for (const moduleName of foundModuleNames) {
-                        const moduleDir = combinePaths(nodeModulesDir, moduleName);
-                        result.push({
-                            moduleName,
-                            moduleDir
-                        });
-                    }
+        if (host.readFile && host.fileExists) {
+            for (const packageJson of findPackageJsons(scriptPath, host)) {
+                const contents = tryReadingPackageJson(packageJson);
+                if (!contents) {
+                    return;
                 }
-            }
 
-            return result;
+                const nodeModulesDir = combinePaths(getDirectoryPath(packageJson), "node_modules");
+                const foundModuleNames: string[] = [];
 
-            function tryReadingPackageJson(filePath: string) {
-                try {
-                    const fileText = tryReadFile(host, filePath);
-                    return fileText ? JSON.parse(fileText) : undefined;
+                // Provide completions for all non @types dependencies
+                for (const key of nodeModulesDependencyKeys) {
+                    addPotentialPackageNames(contents[key], foundModuleNames);
                 }
-                catch (e) {
-                    return undefined;
-                }
-            }
 
-            function addPotentialPackageNames(dependencies: any, result: string[]) {
-                if (dependencies) {
-                    for (const dep in dependencies) {
-                        if (dependencies.hasOwnProperty(dep) && !startsWith(dep, "@types/")) {
-                            result.push(dep);
-                        }
-                    }
+                for (const moduleName of foundModuleNames) {
+                    const moduleDir = combinePaths(nodeModulesDir, moduleName);
+                    result.push({
+                        moduleName,
+                        moduleDir
+                    });
                 }
             }
         }
 
-        function createCompletionEntryForModule(name: string, kind: string, replacementSpan: TextSpan): CompletionEntry {
-            return { name, kind, kindModifiers: ScriptElementKindModifier.none, sortText: name, replacementSpan };
-        }
+        return result;
 
-        // Replace everything after the last directory seperator that appears
-        function getDirectoryFragmentTextSpan(text: string, textStart: number): TextSpan {
-            const index = text.lastIndexOf(directorySeparator);
-            const offset = index !== -1 ? index + 1 : 0;
-            return { start: textStart + offset, length: text.length - offset };
-        }
-
-        // Returns true if the path is explicitly relative to the script (i.e. relative to . or ..)
-        function isPathRelativeToScript(path: string) {
-            if (path && path.length >= 2 && path.charCodeAt(0) === CharacterCodes.dot) {
-                const slashIndex = path.length >= 3 && path.charCodeAt(1) === CharacterCodes.dot ? 2 : 1;
-                const slashCharCode = path.charCodeAt(slashIndex);
-                return slashCharCode === CharacterCodes.slash || slashCharCode === CharacterCodes.backslash;
+        function tryReadingPackageJson(filePath: string) {
+            try {
+                const fileText = tryReadFile(host, filePath);
+                return fileText ? JSON.parse(fileText) : undefined;
+            }
+            catch (e) {
+                return undefined;
             }
-            return false;
         }
 
-        function normalizeAndPreserveTrailingSlash(path: string) {
-            return hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalizePath(path)) : normalizePath(path);
+        function addPotentialPackageNames(dependencies: any, result: string[]) {
+            if (dependencies) {
+                for (const dep in dependencies) {
+                    if (dependencies.hasOwnProperty(dep) && !startsWith(dep, "@types/")) {
+                        result.push(dep);
+                    }
+                }
+            }
         }
     }
 
+    function createCompletionEntryForModule(name: string, kind: string, replacementSpan: TextSpan): CompletionEntry {
+        return { name, kind, kindModifiers: ScriptElementKindModifier.none, sortText: name, replacementSpan };
+    }
+
+    // Replace everything after the last directory seperator that appears
+    function getDirectoryFragmentTextSpan(text: string, textStart: number): TextSpan {
+        const index = text.lastIndexOf(directorySeparator);
+        const offset = index !== -1 ? index + 1 : 0;
+        return { start: textStart + offset, length: text.length - offset };
+    }
+
+    // Returns true if the path is explicitly relative to the script (i.e. relative to . or ..)
+    function isPathRelativeToScript(path: string) {
+        if (path && path.length >= 2 && path.charCodeAt(0) === CharacterCodes.dot) {
+            const slashIndex = path.length >= 3 && path.charCodeAt(1) === CharacterCodes.dot ? 2 : 1;
+            const slashCharCode = path.charCodeAt(slashIndex);
+            return slashCharCode === CharacterCodes.slash || slashCharCode === CharacterCodes.backslash;
+        }
+        return false;
+    }
+
+    function normalizeAndPreserveTrailingSlash(path: string) {
+        return hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalizePath(path)) : normalizePath(path);
+    }
+
     export function getCompletionEntryDetails(typeChecker: TypeChecker, log: (message: string) => void, compilerOptions: CompilerOptions, sourceFile: SourceFile, position: number, entryName: string): CompletionEntryDetails {
         // Compute all the completion symbols again.
         const completionData = getCompletionData(typeChecker, log, sourceFile, position);

From 9fbadfdc67809636a580cd939ea7f815b8214a91 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 08:02:39 -0800
Subject: [PATCH 061/159] Move `"types": []` to tsconfig-base

---
 src/compiler/tsconfig.json | 3 +--
 src/services/tsconfig.json | 3 +--
 src/tsconfig-base.json     | 3 ++-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index 1ed009444b1..52bb92ee1f0 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -3,8 +3,7 @@
     "compilerOptions": {
         "removeComments": true,
         "outFile": "../../built/local/tsc.js",
-        "declaration": true,
-        "types": [ ]
+        "declaration": true
     },
     "files": [
         "core.ts",
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index 13686d232a1..b60e00292f5 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -3,8 +3,7 @@
     "compilerOptions": {
         "removeComments": false,
         "outFile": "../../built/local/typescriptServices.js",
-        "declaration": true,
-        "types": []
+        "declaration": true
     },
     "files": [
         "../compiler/core.ts",
diff --git a/src/tsconfig-base.json b/src/tsconfig-base.json
index b4c82dbeeee..2eb1851dc5c 100644
--- a/src/tsconfig-base.json
+++ b/src/tsconfig-base.json
@@ -9,6 +9,7 @@
         "preserveConstEnums": true,
         "stripInternal": true,
         "sourceMap": true,
-        "target": "es5"
+        "target": "es5",
+        "types": []
     }
 }
\ No newline at end of file

From d1fb894d8661664648a73882f3aca998794ad805 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 10:29:54 -0800
Subject: [PATCH 062/159] Update document highlight tests: Use ranges to
 represent expected highlights

---
 src/harness/fourslash.ts                      | 83 ++++++++++++-------
 ...documentHighlightAtInheritedProperties1.ts | 10 +--
 ...documentHighlightAtInheritedProperties2.ts | 10 +--
 ...documentHighlightAtInheritedProperties3.ts | 14 ++--
 ...documentHighlightAtInheritedProperties4.ts | 14 ++--
 ...documentHighlightAtInheritedProperties5.ts | 29 ++-----
 ...documentHighlightAtInheritedProperties6.ts | 33 +++-----
 ...ighlightAtParameterPropertyDeclaration1.ts | 30 +++----
 ...ighlightAtParameterPropertyDeclaration2.ts | 31 ++++---
 ...ighlightAtParameterPropertyDeclaration3.ts | 31 ++++---
 tests/cases/fourslash/fourslash.ts            |  4 +-
 ...PropertySymbolsFromBaseTypesDoesntCrash.ts |  5 +-
 .../fourslash/server/documentHighlights01.ts  | 12 +--
 .../fourslash/server/documentHighlights02.ts  | 22 +----
 14 files changed, 135 insertions(+), 193 deletions(-)

diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 8ad715681ec..1afb6de2cf2 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -859,9 +859,8 @@ namespace FourSlash {
             }
         }
 
-        public verifyReferencesOf({fileName, start}: Range, references: Range[]) {
-            this.openFile(fileName);
-            this.goToPosition(start);
+        public verifyReferencesOf(range: Range, references: Range[]) {
+            this.goToRangeStart(range);
             this.verifyReferencesAre(references);
         }
 
@@ -1669,6 +1668,11 @@ namespace FourSlash {
             this.goToPosition(len);
         }
 
+        private goToRangeStart({fileName, start}: Range) {
+            this.openFile(fileName);
+            this.goToPosition(start);
+        }
+
         public goToTypeDefinition(definitionIndex: number) {
             const definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (!definitions || !definitions.length) {
@@ -2361,40 +2365,45 @@ namespace FourSlash {
             return this.languageService.getDocumentHighlights(this.activeFile.fileName, this.currentCaretPosition, filesToSearch);
         }
 
-        public verifyDocumentHighlightsAtPositionListContains(fileName: string, start: number, end: number, fileNamesToSearch: string[], kind?: string) {
-            const documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
+        public verifyRangesWithSameTextAreDocumentHighlights() {
+            this.rangesByText().forEach(ranges => this.verifyRangesAreDocumentHighlights(ranges));
+        }
 
-            if (!documentHighlights || documentHighlights.length === 0) {
-                this.raiseError("verifyDocumentHighlightsAtPositionListContains failed - found 0 highlights, expected at least one.");
+        public verifyRangesAreDocumentHighlights(ranges?: Range[]) {
+            ranges = ranges || this.getRanges();
+            const fileNames = unique(ranges, range => range.fileName);
+            for (const range of ranges) {
+                this.goToRangeStart(range);
+                this.verifyDocumentHighlights(ranges, fileNames);
             }
+        }
 
-            for (const documentHighlight of documentHighlights) {
-                if (documentHighlight.fileName === fileName) {
-                    const { highlightSpans } = documentHighlight;
+        private verifyDocumentHighlights(expectedRanges: Range[], fileNames: string[] = [this.activeFile.fileName]) {
+            const documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNames) || [];
 
-                    for (const highlight of highlightSpans) {
-                        if (highlight && highlight.textSpan.start === start && ts.textSpanEnd(highlight.textSpan) === end) {
-                            if (typeof kind !== "undefined" && highlight.kind !== kind) {
-                                this.raiseError(`verifyDocumentHighlightsAtPositionListContains failed - item "kind" value does not match, actual: ${highlight.kind}, expected: ${kind}.`);
-                            }
-                            return;
-                        }
-                    }
+            for (const dh of documentHighlights) {
+                if (fileNames.indexOf(dh.fileName) === -1) {
+                    this.raiseError(`verifyDocumentHighlights failed - got highlights in unexpected file name ${dh.fileName}`);
                 }
             }
 
-            const missingItem = { fileName: fileName, start: start, end: end, kind: kind };
-            this.raiseError(`verifyDocumentHighlightsAtPositionListContains failed - could not find the item: ${stringify(missingItem)} in the returned list: (${stringify(documentHighlights)})`);
-        }
+            for (const fileName of fileNames) {
+                const expectedRangesInFile = expectedRanges.filter(r => r.fileName === fileName);
+                const highlights = ts.find(documentHighlights, dh => dh.fileName === fileName);
+                if (!highlights) {
+                    this.raiseError(`verifyDocumentHighlights failed - found no highlights in ${fileName}`);
+                }
+                const spansInFile = highlights.highlightSpans.sort((s1, s2) => s1.textSpan.start - s2.textSpan.start);
 
-        public verifyDocumentHighlightsAtPositionListCount(expectedCount: number, fileNamesToSearch: string[]) {
-            const documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
-            const actualCount = documentHighlights
-                ? documentHighlights.reduce((currentCount, { highlightSpans }) => currentCount + highlightSpans.length, 0)
-                : 0;
+                if (expectedRangesInFile.length !== spansInFile.length) {
+                    this.raiseError(`verifyDocumentHighlights failed - In ${fileName}, expected ${expectedRangesInFile.length} highlights, got ${spansInFile.length}`);
+                }
 
-            if (expectedCount !== actualCount) {
-                this.raiseError("verifyDocumentHighlightsAtPositionListCount failed - actual: " + actualCount + ", expected:" + expectedCount);
+                ts.zipWith(expectedRangesInFile, spansInFile, (expectedRange, span) => {
+                    if (span.textSpan.start !== expectedRange.start || ts.textSpanEnd(span.textSpan) !== expectedRange.end) {
+                        this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${JSON.stringify(span.textSpan)}, expected: ${expectedRange.start}--${expectedRange.end}`);
+                    }
+                });
             }
         }
 
@@ -3021,6 +3030,16 @@ ${code}
     function stringify(data: any, replacer?: (key: string, value: any) => any): string {
         return JSON.stringify(data, replacer, 2);
     }
+
+    /** Collects an array of unique outputs. */
+    function unique<T>(inputs: T[], getOutput: (t: T) => string): string[] {
+        const set = ts.createMap<true>();
+        for (const input of inputs) {
+            const out = getOutput(input);
+            set.set(out, true);
+        }
+        return ts.arrayFrom(set.keys());
+    }
 }
 
 namespace FourSlashInterface {
@@ -3413,12 +3432,12 @@ namespace FourSlashInterface {
             this.state.verifyOccurrencesAtPositionListCount(expectedCount);
         }
 
-        public documentHighlightsAtPositionContains(range: FourSlash.Range, fileNamesToSearch: string[], kind?: string) {
-            this.state.verifyDocumentHighlightsAtPositionListContains(range.fileName, range.start, range.end, fileNamesToSearch, kind);
+        public rangesAreDocumentHighlights(ranges?: FourSlash.Range[]) {
+            this.state.verifyRangesAreDocumentHighlights(ranges);
         }
 
-        public documentHighlightsAtPositionCount(expectedCount: number, fileNamesToSearch: string[]) {
-            this.state.verifyDocumentHighlightsAtPositionListCount(expectedCount, fileNamesToSearch);
+        public rangesWithSameTextAreDocumentHighlights() {
+            this.state.verifyRangesWithSameTextAreDocumentHighlights();
         }
 
         public completionEntryDetailIs(entryName: string, text: string, documentation?: string, kind?: string) {
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties1.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties1.ts
index 23f6445a004..0c07edea506 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties1.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties1.ts
@@ -2,12 +2,8 @@
 
 // @Filename: file1.ts
 //// interface interface1 extends interface1 {
-////    /*1*/doStuff(): void;
-////    /*2*/propName: string;
+////    [|doStuff|](): void;
+////    [|propName|]: string;
 //// }
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
-}
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties2.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties2.ts
index d4aadf96ed6..3327c36b760 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties2.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties2.ts
@@ -2,12 +2,8 @@
 
 // @Filename: file1.ts
 //// class class1 extends class1 {
-////    /*1*/doStuff() { }
-////    /*2*/propName: string;
+////    [|doStuff|]() { }
+////    [|propName|]: string;
 //// }
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
-}
\ No newline at end of file
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties3.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties3.ts
index 5e94bb387cd..11625df1442 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties3.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties3.ts
@@ -2,16 +2,12 @@
 
 // @Filename: file1.ts
 //// interface interface1 extends interface1 {
-////    /*1*/doStuff(): void;
-////    /*2*/propName: string;
+////    [|doStuff|](): void;
+////    [|propName|]: string;
 //// }
 ////
 //// var v: interface1;
-//// v./*3*/propName;
-//// v./*4*/doStuff();
+//// v.[|propName|];
+//// v.[|doStuff|]();
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-}
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties4.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties4.ts
index 50f459ebfdb..1c78233554a 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties4.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties4.ts
@@ -2,16 +2,12 @@
 
 // @Filename: file1.ts
 //// class class1 extends class1 {
-////    /*1*/doStuff() { }
-////    /*2*/propName: string;
+////    [|doStuff|]() { }
+////    [|propName|]: string;
 //// }
 ////
 //// var c: class1;
-//// c./*3*/doStuff();
-//// c./*4*/propName;
+//// c.[|doStuff|]();
+//// c.[|propName|];
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-}
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties5.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties5.ts
index b5f4cbb00a7..4fdf4a689ac 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties5.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties5.ts
@@ -2,29 +2,16 @@
 
 // @Filename: file1.ts
 //// interface C extends D {
-////     /*0*/prop0: string;
-////     /*1*/prop1: number;
+////     [|prop0|]: string;
+////     [|prop1|]: number;
 //// }
-//// 
+////
 //// interface D extends C {
-////     /*2*/prop0: string;
-////     /*3*/prop1: number;
+////     [|prop0|]: string;
+////     [|prop1|]: number;
 //// }
-//// 
+////
 //// var d: D;
-//// d./*4*/prop1;
+//// d.[|prop1|];
 
-goTo.marker("0");
-verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-
-goTo.marker("1");
-verify.documentHighlightsAtPositionCount(3, ["file1.ts"]);
-
-goTo.marker("2");
-verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-
-goTo.marker("3");
-verify.documentHighlightsAtPositionCount(3, ["file1.ts"]);
-
-goTo.marker("4");
-verify.documentHighlightsAtPositionCount(3, ["file1.ts"]);
\ No newline at end of file
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtInheritedProperties6.ts b/tests/cases/fourslash/documentHighlightAtInheritedProperties6.ts
index 8f1089e567d..6eb7ae16723 100644
--- a/tests/cases/fourslash/documentHighlightAtInheritedProperties6.ts
+++ b/tests/cases/fourslash/documentHighlightAtInheritedProperties6.ts
@@ -2,29 +2,20 @@
 
 // @Filename: file1.ts
 //// class C extends D {
-////     /*0*/prop0: string;
-////     /*1*/prop1: string;
+////     [|prop0|]: string;
+////     [|prop1|]: string;
 //// }
-//// 
+////
 //// class D extends C {
-////     /*2*/prop0: string;
-////     /*3*/prop1: string;
+////     [|prop0|]: string;
+////     [|prop1|]: string;
 //// }
-//// 
+////
 //// var d: D;
-//// d./*4*/prop1;
+//// d.[|prop1|];
 
-goTo.marker("0");
-verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
-
-goTo.marker("1");
-verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
-
-goTo.marker("2");
-verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
-
-goTo.marker("3");
-verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-
-goTo.marker("4");
-verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
\ No newline at end of file
+const [Cprop0, Cprop1, Dprop0, Dprop1, prop1Use] = test.ranges();
+verify.rangesAreDocumentHighlights([Cprop0]);
+verify.rangesAreDocumentHighlights([Dprop0]);
+verify.rangesAreDocumentHighlights([Cprop1]);
+verify.rangesAreDocumentHighlights([Dprop1, prop1Use]);
diff --git a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration1.ts b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration1.ts
index aeccd252fe9..219ea427b9c 100644
--- a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration1.ts
+++ b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration1.ts
@@ -2,23 +2,19 @@
 
 // @Filename: file1.ts
 //// class Foo {
-////     constructor(private /*0*/privateParam: number,
-////         public /*1*/publicParam: string,
-////         protected /*2*/protectedParam: boolean) {
-//// 
-////         let localPrivate = /*3*/privateParam;
-////         this./*4*/privateParam += 10;
-//// 
-////         let localPublic = /*5*/publicParam;
-////         this./*6*/publicParam += " Hello!";
-//// 
-////         let localProtected = /*7*/protectedParam;
-////         this./*8*/protectedParam = false;
+////     constructor(private [|privateParam|]: number,
+////         public [|publicParam|]: string,
+////         protected [|protectedParam|]: boolean) {
+////
+////         let localPrivate = [|privateParam|];
+////         this.[|privateParam|] += 10;
+////
+////         let localPublic = [|publicParam|];
+////         this.[|publicParam|] += " Hello!";
+////
+////         let localProtected = [|protectedParam|];
+////         this.[|protectedParam|] = false;
 ////     }
 //// }
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(3, ["file1.ts"]);
-}
\ No newline at end of file
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration2.ts b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration2.ts
index f5d6764205b..199f59fc8a3 100644
--- a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration2.ts
+++ b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration2.ts
@@ -2,23 +2,20 @@
 
 // @Filename: file1.ts
 //// class Foo {
-////     constructor(private {/*0*/privateParam}: number,
-////         public {/*1*/publicParam}: string,
-////         protected {/*2*/protectedParam}: boolean) {
-//// 
-////         let localPrivate = /*3*/privateParam;
-////         this.privateParam += 10; // this is not valid syntax
-//// 
-////         let localPublic = /*4*/publicParam;
-////         this.publicParam += " Hello!";  // this is not valid syntax
-//// 
-////         let localProtected = /*5*/protectedParam;
-////         this.protectedParam = false;  // this is not valid syntax
+////     // This is not valid syntax: parameter property can't be binding pattern
+////     constructor(private {[|privateParam|]}: number,
+////         public {[|publicParam|]}: string,
+////         protected {[|protectedParam|]}: boolean) {
+////
+////         let localPrivate = [|privateParam|];
+////         this.privateParam += 10;
+////
+////         let localPublic = [|publicParam|];
+////         this.publicParam += " Hello!";
+////
+////         let localProtected = [|protectedParam|];
+////         this.protectedParam = false;
 ////     }
 //// }
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-}
\ No newline at end of file
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration3.ts b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration3.ts
index 958e3bb45c9..7bcd44a5425 100644
--- a/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration3.ts
+++ b/tests/cases/fourslash/documentHighlightAtParameterPropertyDeclaration3.ts
@@ -2,23 +2,20 @@
 
 // @Filename: file1.ts
 //// class Foo {
-////     constructor(private [/*0*/privateParam]: number,
-////         public [/*1*/publicParam]: string,
-////         protected [/*2*/protectedParam]: boolean) {
-//// 
-////         let localPrivate = /*3*/privateParam;
-////         this.privateParam += 10;  // this is not valid syntax
-//// 
-////         let localPublic = /*4*/publicParam;
-////         this.publicParam += " Hello!";  // this is not valid syntax
-//// 
-////         let localProtected = /*5*/protectedParam;
-////         this.protectedParam = false;  // this is not valid syntax
+////     // This is not valid syntax: parameter property can't be binding pattern
+////     constructor(private [[|privateParam|]]: number,
+////         public [[|publicParam|]]: string,
+////         protected [[|protectedParam|]]: boolean) {
+////
+////         let localPrivate = [|privateParam|];
+////         this.privateParam += 10;
+////
+////         let localPublic = [|publicParam|];
+////         this.publicParam += " Hello!";
+////
+////         let localProtected = [|protectedParam|];
+////         this.protectedParam = false;
 ////     }
 //// }
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-    verify.documentHighlightsAtPositionCount(2, ["file1.ts"]);
-}
\ No newline at end of file
+verify.rangesWithSameTextAreDocumentHighlights();
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index ab67abc1bb6..ed09fcd2c92 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -229,8 +229,8 @@ declare namespace FourSlashInterface {
         navigationItemsListContains(name: string, kind: string, searchValue: string, matchKind: string, fileName?: string, parentName?: string): void;
         occurrencesAtPositionContains(range: Range, isWriteAccess?: boolean): void;
         occurrencesAtPositionCount(expectedCount: number): void;
-        documentHighlightsAtPositionContains(range: Range, fileNamesToSearch: string[], kind?: string): void;
-        documentHighlightsAtPositionCount(expectedCount: number, fileNamesToSearch: string[]): void;
+        rangesAreDocumentHighlights(ranges?: Range[]): void;
+        rangesWithSameTextAreDocumentHighlights(): void;
         completionEntryDetailIs(entryName: string, text: string, documentation?: string, kind?: string): void;
         /**
          * This method *requires* a contiguous, complete, and ordered stream of classifications for a file.
diff --git a/tests/cases/fourslash/getPropertySymbolsFromBaseTypesDoesntCrash.ts b/tests/cases/fourslash/getPropertySymbolsFromBaseTypesDoesntCrash.ts
index 0c89de63a43..e141a257f2e 100644
--- a/tests/cases/fourslash/getPropertySymbolsFromBaseTypesDoesntCrash.ts
+++ b/tests/cases/fourslash/getPropertySymbolsFromBaseTypesDoesntCrash.ts
@@ -2,8 +2,7 @@
 
 // @Filename: file1.ts
 //// class ClassA implements IInterface {
-////     private /*1*/value: number;
+////     private [|value|]: number;
 //// }
 
-goTo.marker("1");
-verify.documentHighlightsAtPositionCount(1, ["file1.ts"]);
\ No newline at end of file
+verify.rangesAreDocumentHighlights();
diff --git a/tests/cases/fourslash/server/documentHighlights01.ts b/tests/cases/fourslash/server/documentHighlights01.ts
index d4be88f9357..0acfbcb9d11 100644
--- a/tests/cases/fourslash/server/documentHighlights01.ts
+++ b/tests/cases/fourslash/server/documentHighlights01.ts
@@ -5,14 +5,4 @@
 ////    [|f|]([|f|]);
 ////}
 
-let ranges = test.ranges();
-
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.documentHighlightsAtPositionCount(ranges.length, ["a.ts"]);
-
-    for (let range of ranges) {
-        verify.documentHighlightsAtPositionContains(range, ["a.ts"]);
-    }
-}
-
+verify.rangesAreDocumentHighlights();
diff --git a/tests/cases/fourslash/server/documentHighlights02.ts b/tests/cases/fourslash/server/documentHighlights02.ts
index 357f82e9c2d..3fd71d4a65d 100644
--- a/tests/cases/fourslash/server/documentHighlights02.ts
+++ b/tests/cases/fourslash/server/documentHighlights02.ts
@@ -8,28 +8,10 @@
 
 // @Filename: b.ts
 /////// <reference path="a.ts"/>
-////foo();
+////[|foo|]();
 
 // open two files
 goTo.file("a.ts");
 goTo.file("b.ts");
 
-let ranges = test.ranges();
-
-for (let i = 0; i < ranges.length; ++i) {
-	let r = ranges[i];
-
-	if (i < 2) {
-		goTo.file("a.ts");
-	}
-	else {
-		goTo.file("b.ts");
-	}
-
-    goTo.position(r.start);
-    verify.documentHighlightsAtPositionCount(3, ["a.ts", "b.ts"]);
-
-    for (let range of ranges) {
-        verify.documentHighlightsAtPositionContains(range, ["a.ts", "b.ts"]);
-    }
-}
+verify.rangesAreDocumentHighlights();

From 9ebdd30ce41b30d1e8ef841e8a84a2d92df19ac1 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 14:36:55 -0800
Subject: [PATCH 063/159] Remove added newline

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

diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 840ebaa1662..1dd41f9d81c 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -55,7 +55,6 @@ interface XMLHttpRequest  {
 }
 /* tslint:enable:no-var-keyword */
 
-
 namespace Utils {
     // Setup some globals based on the current environment
     export const enum ExecutionEnvironment {

From bddcbc5f20dec6b3148f61fd1bc1223c1bda870d Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 14:30:40 -0800
Subject: [PATCH 064/159] Move code out of closure in `getDocumentHighlights`,
 then again out of `getSemanticDocumentHighlights` and
 `getSyntacticDocumentHighlights`.

Also return a `Node[]` instead of a `HighlightSpan[]` where possible and do mapping from Node to HighlightSpan in one place.
---
 src/services/documentHighlights.ts | 1192 ++++++++++++++--------------
 1 file changed, 593 insertions(+), 599 deletions(-)

diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 212e145ca60..79fa0236bc5 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -2,626 +2,620 @@
 namespace ts.DocumentHighlights {
     export function getDocumentHighlights(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, position: number, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
         const node = getTouchingWord(sourceFile, position);
+        return node && (getSemanticDocumentHighlights(node, typeChecker, cancellationToken, sourceFilesToSearch) || getSyntacticDocumentHighlights(node, sourceFile));
+    }
+
+    function getHighlightSpanForNode(node: Node, sourceFile: SourceFile): HighlightSpan {
+        const start = node.getStart(sourceFile);
+        const end = node.getEnd();
+
+        return {
+            fileName: sourceFile.fileName,
+            textSpan: createTextSpanFromBounds(start, end),
+            kind: HighlightSpanKind.none
+        };
+    }
+
+    function getSemanticDocumentHighlights(node: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
+        if (node.kind === SyntaxKind.Identifier ||
+            node.kind === SyntaxKind.ThisKeyword ||
+            node.kind === SyntaxKind.ThisType ||
+            node.kind === SyntaxKind.SuperKeyword ||
+            node.kind === SyntaxKind.StringLiteral ||
+            isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+
+            const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false, /*implementations*/false);
+            return convertReferencedSymbols(referencedSymbols);
+        }
+
+        return undefined;
+    }
+
+    function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
+        if (!referencedSymbols) {
+            return undefined;
+        }
+
+        const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
+        const result: DocumentHighlights[] = [];
+        for (const referencedSymbol of referencedSymbols) {
+            for (const referenceEntry of referencedSymbol.references) {
+                const fileName = referenceEntry.fileName;
+                let documentHighlights = fileNameToDocumentHighlights.get(fileName);
+                if (!documentHighlights) {
+                    documentHighlights = { fileName, highlightSpans: [] };
+
+                    fileNameToDocumentHighlights.set(fileName, documentHighlights);
+                    result.push(documentHighlights);
+                }
+
+                documentHighlights.highlightSpans.push({
+                    textSpan: referenceEntry.textSpan,
+                    kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
+                });
+            }
+        }
+
+        return result;
+    }
+
+    function getSyntacticDocumentHighlights(node: Node, sourceFile: SourceFile): DocumentHighlights[] {
+        const highlightSpans = getHighlightSpans(node, sourceFile);
+        if (!highlightSpans || highlightSpans.length === 0) {
+            return undefined;
+        }
+
+        return [{ fileName: sourceFile.fileName, highlightSpans }];
+    }
+
+    // returns true if 'node' is defined and has a matching 'kind'.
+    function hasKind(node: Node, kind: SyntaxKind) {
+        return node !== undefined && node.kind === kind;
+    }
+
+    // Null-propagating 'parent' function.
+    function parent(node: Node): Node {
+        return node && node.parent;
+    }
+
+    function getHighlightSpans(node: Node, sourceFile: SourceFile): HighlightSpan[] {
         if (!node) {
             return undefined;
         }
 
-        return getSemanticDocumentHighlights(node) || getSyntacticDocumentHighlights(node);
-
-        function getHighlightSpanForNode(node: Node): HighlightSpan {
-            const start = node.getStart();
-            const end = node.getEnd();
-
-            return {
-                fileName: sourceFile.fileName,
-                textSpan: createTextSpanFromBounds(start, end),
-                kind: HighlightSpanKind.none
-            };
+        switch (node.kind) {
+            case SyntaxKind.IfKeyword:
+            case SyntaxKind.ElseKeyword:
+                if (hasKind(node.parent, SyntaxKind.IfStatement)) {
+                    return getIfElseOccurrences(<IfStatement>node.parent, sourceFile);
+                }
+                break;
+            case SyntaxKind.ReturnKeyword:
+                if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
+                    return highlightSpans(getReturnOccurrences(<ReturnStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.ThrowKeyword:
+                if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
+                    return highlightSpans(getThrowOccurrences(<ThrowStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.TryKeyword:
+            case SyntaxKind.CatchKeyword:
+            case SyntaxKind.FinallyKeyword:
+                const tryStatement = node.kind === SyntaxKind.CatchKeyword ? parent(parent(node)) : parent(node);
+                if (hasKind(tryStatement, SyntaxKind.TryStatement)) {
+                    return highlightSpans(getTryCatchFinallyOccurrences(<TryStatement>tryStatement, sourceFile));
+                }
+                break;
+            case SyntaxKind.SwitchKeyword:
+                if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
+                    return highlightSpans(getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.CaseKeyword:
+            case SyntaxKind.DefaultKeyword:
+                if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
+                    return highlightSpans(getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent));
+                }
+                break;
+            case SyntaxKind.BreakKeyword:
+            case SyntaxKind.ContinueKeyword:
+                if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
+                    return highlightSpans(getBreakOrContinueStatementOccurrences(<BreakOrContinueStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.ForKeyword:
+                if (hasKind(node.parent, SyntaxKind.ForStatement) ||
+                    hasKind(node.parent, SyntaxKind.ForInStatement) ||
+                    hasKind(node.parent, SyntaxKind.ForOfStatement)) {
+                    return highlightSpans(getLoopBreakContinueOccurrences(<IterationStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.WhileKeyword:
+            case SyntaxKind.DoKeyword:
+                if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
+                    return highlightSpans(getLoopBreakContinueOccurrences(<IterationStatement>node.parent));
+                }
+                break;
+            case SyntaxKind.ConstructorKeyword:
+                if (hasKind(node.parent, SyntaxKind.Constructor)) {
+                    return highlightSpans(getConstructorOccurrences(<ConstructorDeclaration>node.parent));
+                }
+                break;
+            case SyntaxKind.GetKeyword:
+            case SyntaxKind.SetKeyword:
+                if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
+                    return highlightSpans(getGetAndSetOccurrences(<AccessorDeclaration>node.parent));
+                }
+                break;
+            default:
+                if (isModifierKind(node.kind) && node.parent &&
+                    (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
+                    return highlightSpans(getModifierOccurrences(node.kind, node.parent));
+                }
         }
 
-        function getSemanticDocumentHighlights(node: Node): DocumentHighlights[] {
-            if (node.kind === SyntaxKind.Identifier ||
-                node.kind === SyntaxKind.ThisKeyword ||
-                node.kind === SyntaxKind.ThisType ||
-                node.kind === SyntaxKind.SuperKeyword ||
-                node.kind === SyntaxKind.StringLiteral ||
-                isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
-
-                const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false, /*implementations*/false);
-                return convertReferencedSymbols(referencedSymbols);
-
-            }
-
-            return undefined;
-
-            function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
-                if (!referencedSymbols) {
-                    return undefined;
-                }
-
-                const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
-                const result: DocumentHighlights[] = [];
-                for (const referencedSymbol of referencedSymbols) {
-                    for (const referenceEntry of referencedSymbol.references) {
-                        const fileName = referenceEntry.fileName;
-                        let documentHighlights = fileNameToDocumentHighlights.get(fileName);
-                        if (!documentHighlights) {
-                            documentHighlights = { fileName, highlightSpans: [] };
-
-                            fileNameToDocumentHighlights.set(fileName, documentHighlights);
-                            result.push(documentHighlights);
-                        }
-
-                        documentHighlights.highlightSpans.push({
-                            textSpan: referenceEntry.textSpan,
-                            kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
-                        });
-                    }
-                }
-
-                return result;
-            }
+        function highlightSpans(nodes: Node[]): HighlightSpan[] {
+            return nodes && nodes.map(node => getHighlightSpanForNode(node, sourceFile));
         }
+    }
 
-        function getSyntacticDocumentHighlights(node: Node): DocumentHighlights[] {
-            const fileName = sourceFile.fileName;
+    /**
+     * Aggregates all throw-statements within this node *without* crossing
+     * into function boundaries and try-blocks with catch-clauses.
+     */
+    function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
+        const statementAccumulator: ThrowStatement[] = [];
+        aggregate(node);
+        return statementAccumulator;
 
-            const highlightSpans = getHighlightSpans(node);
-            if (!highlightSpans || highlightSpans.length === 0) {
-                return undefined;
+        function aggregate(node: Node): void {
+            if (node.kind === SyntaxKind.ThrowStatement) {
+                statementAccumulator.push(<ThrowStatement>node);
             }
-
-            return [{ fileName, highlightSpans }];
-
-            // returns true if 'node' is defined and has a matching 'kind'.
-            function hasKind(node: Node, kind: SyntaxKind) {
-                return node !== undefined && node.kind === kind;
-            }
-
-            // Null-propagating 'parent' function.
-            function parent(node: Node): Node {
-                return node && node.parent;
-            }
-
-            function getHighlightSpans(node: Node): HighlightSpan[] {
-                if (node) {
-                    switch (node.kind) {
-                        case SyntaxKind.IfKeyword:
-                        case SyntaxKind.ElseKeyword:
-                            if (hasKind(node.parent, SyntaxKind.IfStatement)) {
-                                return getIfElseOccurrences(<IfStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.ReturnKeyword:
-                            if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
-                                return getReturnOccurrences(<ReturnStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.ThrowKeyword:
-                            if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
-                                return getThrowOccurrences(<ThrowStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.CatchKeyword:
-                            if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
-                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
-                            }
-                            break;
-                        case SyntaxKind.TryKeyword:
-                        case SyntaxKind.FinallyKeyword:
-                            if (hasKind(parent(node), SyntaxKind.TryStatement)) {
-                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.SwitchKeyword:
-                            if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
-                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.CaseKeyword:
-                        case SyntaxKind.DefaultKeyword:
-                            if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
-                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent);
-                            }
-                            break;
-                        case SyntaxKind.BreakKeyword:
-                        case SyntaxKind.ContinueKeyword:
-                            if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
-                                return getBreakOrContinueStatementOccurrences(<BreakOrContinueStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.ForKeyword:
-                            if (hasKind(node.parent, SyntaxKind.ForStatement) ||
-                                hasKind(node.parent, SyntaxKind.ForInStatement) ||
-                                hasKind(node.parent, SyntaxKind.ForOfStatement)) {
-                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.WhileKeyword:
-                        case SyntaxKind.DoKeyword:
-                            if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
-                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.ConstructorKeyword:
-                            if (hasKind(node.parent, SyntaxKind.Constructor)) {
-                                return getConstructorOccurrences(<ConstructorDeclaration>node.parent);
-                            }
-                            break;
-                        case SyntaxKind.GetKeyword:
-                        case SyntaxKind.SetKeyword:
-                            if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
-                                return getGetAndSetOccurrences(<AccessorDeclaration>node.parent);
-                            }
-                            break;
-                        default:
-                            if (isModifierKind(node.kind) && node.parent &&
-                                (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
-                                return getModifierOccurrences(node.kind, node.parent);
-                            }
-                    }
-                }
-
-                return undefined;
-            }
-
-            /**
-             * Aggregates all throw-statements within this node *without* crossing
-             * into function boundaries and try-blocks with catch-clauses.
-             */
-            function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
-                const statementAccumulator: ThrowStatement[] = [];
-                aggregate(node);
-                return statementAccumulator;
-
-                function aggregate(node: Node): void {
-                    if (node.kind === SyntaxKind.ThrowStatement) {
-                        statementAccumulator.push(<ThrowStatement>node);
-                    }
-                    else if (node.kind === SyntaxKind.TryStatement) {
-                        const tryStatement = <TryStatement>node;
-
-                        if (tryStatement.catchClause) {
-                            aggregate(tryStatement.catchClause);
-                        }
-                        else {
-                            // Exceptions thrown within a try block lacking a catch clause
-                            // are "owned" in the current context.
-                            aggregate(tryStatement.tryBlock);
-                        }
-
-                        if (tryStatement.finallyBlock) {
-                            aggregate(tryStatement.finallyBlock);
-                        }
-                    }
-                    // Do not cross function boundaries.
-                    else if (!isFunctionLike(node)) {
-                        forEachChild(node, aggregate);
-                    }
-                }
-            }
-
-            /**
-             * For lack of a better name, this function takes a throw statement and returns the
-             * nearest ancestor that is a try-block (whose try statement has a catch clause),
-             * function-block, or source file.
-             */
-            function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
-                let child: Node = throwStatement;
-
-                while (child.parent) {
-                    const parent = child.parent;
-
-                    if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
-                        return parent;
-                    }
-
-                    // A throw-statement is only owned by a try-statement if the try-statement has
-                    // a catch clause, and if the throw-statement occurs within the try block.
-                    if (parent.kind === SyntaxKind.TryStatement) {
-                        const tryStatement = <TryStatement>parent;
-
-                        if (tryStatement.tryBlock === child && tryStatement.catchClause) {
-                            return child;
-                        }
-                    }
-
-                    child = parent;
-                }
-
-                return undefined;
-            }
-
-            function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
-                const statementAccumulator: BreakOrContinueStatement[] = [];
-                aggregate(node);
-                return statementAccumulator;
-
-                function aggregate(node: Node): void {
-                    if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
-                        statementAccumulator.push(<BreakOrContinueStatement>node);
-                    }
-                    // Do not cross function boundaries.
-                    else if (!isFunctionLike(node)) {
-                        forEachChild(node, aggregate);
-                    }
-                }
-            }
-
-            function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
-                const actualOwner = getBreakOrContinueOwner(statement);
-
-                return actualOwner && actualOwner === owner;
-            }
-
-            function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
-                for (let node = statement.parent; node; node = node.parent) {
-                    switch (node.kind) {
-                        case SyntaxKind.SwitchStatement:
-                            if (statement.kind === SyntaxKind.ContinueStatement) {
-                                continue;
-                            }
-                        // Fall through.
-                        case SyntaxKind.ForStatement:
-                        case SyntaxKind.ForInStatement:
-                        case SyntaxKind.ForOfStatement:
-                        case SyntaxKind.WhileStatement:
-                        case SyntaxKind.DoStatement:
-                            if (!statement.label || isLabeledBy(node, statement.label.text)) {
-                                return node;
-                            }
-                            break;
-                        default:
-                            // Don't cross function boundaries.
-                            if (isFunctionLike(node)) {
-                                return undefined;
-                            }
-                            break;
-                    }
-                }
-
-                return undefined;
-            }
-
-            function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): HighlightSpan[] {
-                const container = declaration.parent;
-
-                // Make sure we only highlight the keyword when it makes sense to do so.
-                if (isAccessibilityModifier(modifier)) {
-                    if (!(container.kind === SyntaxKind.ClassDeclaration ||
-                        container.kind === SyntaxKind.ClassExpression ||
-                        (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
-                        return undefined;
-                    }
-                }
-                else if (modifier === SyntaxKind.StaticKeyword) {
-                    if (!(container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression)) {
-                        return undefined;
-                    }
-                }
-                else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
-                    if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
-                        return undefined;
-                    }
-                }
-                else if (modifier === SyntaxKind.AbstractKeyword) {
-                    if (!(container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration)) {
-                        return undefined;
-                    }
-                }
-                else {
-                    // unsupported modifier
-                    return undefined;
-                }
-
-                const keywords: Node[] = [];
-                const modifierFlag: ModifierFlags = getFlagFromModifier(modifier);
-
-                let nodes: Node[];
-                switch (container.kind) {
-                    case SyntaxKind.ModuleBlock:
-                    case SyntaxKind.SourceFile:
-                        // Container is either a class declaration or the declaration is a classDeclaration
-                        if (modifierFlag & ModifierFlags.Abstract) {
-                            nodes = (<Node[]>(<ClassDeclaration>declaration).members).concat(declaration);
-                        }
-                        else {
-                            nodes = (<Block>container).statements;
-                        }
-                        break;
-                    case SyntaxKind.Constructor:
-                        nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
-                            (<ClassDeclaration>container.parent).members);
-                        break;
-                    case SyntaxKind.ClassDeclaration:
-                    case SyntaxKind.ClassExpression:
-                        nodes = (<ClassLikeDeclaration>container).members;
-
-                        // If we're an accessibility modifier, we're in an instance member and should search
-                        // the constructor's parameter list for instance members as well.
-                        if (modifierFlag & ModifierFlags.AccessibilityModifier) {
-                            const constructor = forEach((<ClassLikeDeclaration>container).members, member => {
-                                return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
-                            });
-
-                            if (constructor) {
-                                nodes = nodes.concat(constructor.parameters);
-                            }
-                        }
-                        else if (modifierFlag & ModifierFlags.Abstract) {
-                            nodes = nodes.concat(container);
-                        }
-                        break;
-                    default:
-                        Debug.fail("Invalid container kind.");
-                }
-
-                forEach(nodes, node => {
-                    if (getModifierFlags(node) & modifierFlag) {
-                        forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
-                    }
-                });
-
-                return map(keywords, getHighlightSpanForNode);
-
-                function getFlagFromModifier(modifier: SyntaxKind) {
-                    switch (modifier) {
-                        case SyntaxKind.PublicKeyword:
-                            return ModifierFlags.Public;
-                        case SyntaxKind.PrivateKeyword:
-                            return ModifierFlags.Private;
-                        case SyntaxKind.ProtectedKeyword:
-                            return ModifierFlags.Protected;
-                        case SyntaxKind.StaticKeyword:
-                            return ModifierFlags.Static;
-                        case SyntaxKind.ExportKeyword:
-                            return ModifierFlags.Export;
-                        case SyntaxKind.DeclareKeyword:
-                            return ModifierFlags.Ambient;
-                        case SyntaxKind.AbstractKeyword:
-                            return ModifierFlags.Abstract;
-                        default:
-                            Debug.fail();
-                    }
-                }
-            }
-
-            function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
-                if (token && contains(expected, token.kind)) {
-                    keywordList.push(token);
-                    return true;
-                }
-
-                return false;
-            }
-
-            function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): HighlightSpan[] {
-                const keywords: Node[] = [];
-
-                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
-                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
-
-                return map(keywords, getHighlightSpanForNode);
-
-                function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
-                    const accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
-
-                    if (accessor) {
-                        forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
-                    }
-                }
-            }
-
-            function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): HighlightSpan[] {
-                const declarations = constructorDeclaration.symbol.getDeclarations();
-
-                const keywords: Node[] = [];
-
-                forEach(declarations, declaration => {
-                    forEach(declaration.getChildren(), token => {
-                        return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
-                    });
-                });
-
-                return map(keywords, getHighlightSpanForNode);
-            }
-
-            function getLoopBreakContinueOccurrences(loopNode: IterationStatement): HighlightSpan[] {
-                const keywords: Node[] = [];
-
-                if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
-                    // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
-                    if (loopNode.kind === SyntaxKind.DoStatement) {
-                        const loopTokens = loopNode.getChildren();
-
-                        for (let i = loopTokens.length - 1; i >= 0; i--) {
-                            if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                const breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
-
-                forEach(breaksAndContinues, statement => {
-                    if (ownsBreakOrContinueStatement(loopNode, statement)) {
-                        pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
-                    }
-                });
-
-                return map(keywords, getHighlightSpanForNode);
-            }
-
-            function getBreakOrContinueStatementOccurrences(breakOrContinueStatement: BreakOrContinueStatement): HighlightSpan[] {
-                const owner = getBreakOrContinueOwner(breakOrContinueStatement);
-
-                if (owner) {
-                    switch (owner.kind) {
-                        case SyntaxKind.ForStatement:
-                        case SyntaxKind.ForInStatement:
-                        case SyntaxKind.ForOfStatement:
-                        case SyntaxKind.DoStatement:
-                        case SyntaxKind.WhileStatement:
-                            return getLoopBreakContinueOccurrences(<IterationStatement>owner);
-                        case SyntaxKind.SwitchStatement:
-                            return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
-
-                    }
-                }
-
-                return undefined;
-            }
-
-            function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): HighlightSpan[] {
-                const keywords: Node[] = [];
-
-                pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
-
-                // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
-                forEach(switchStatement.caseBlock.clauses, clause => {
-                    pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
-
-                    const breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
-
-                    forEach(breaksAndContinues, statement => {
-                        if (ownsBreakOrContinueStatement(switchStatement, statement)) {
-                            pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
-                        }
-                    });
-                });
-
-                return map(keywords, getHighlightSpanForNode);
-            }
-
-            function getTryCatchFinallyOccurrences(tryStatement: TryStatement): HighlightSpan[] {
-                const keywords: Node[] = [];
-
-                pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+            else if (node.kind === SyntaxKind.TryStatement) {
+                const tryStatement = <TryStatement>node;
 
                 if (tryStatement.catchClause) {
-                    pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+                    aggregate(tryStatement.catchClause);
+                }
+                else {
+                    // Exceptions thrown within a try block lacking a catch clause
+                    // are "owned" in the current context.
+                    aggregate(tryStatement.tryBlock);
                 }
 
                 if (tryStatement.finallyBlock) {
-                    const finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
-                    pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+                    aggregate(tryStatement.finallyBlock);
                 }
-
-                return map(keywords, getHighlightSpanForNode);
             }
-
-            function getThrowOccurrences(throwStatement: ThrowStatement): HighlightSpan[] {
-                const owner = getThrowStatementOwner(throwStatement);
-
-                if (!owner) {
-                    return undefined;
-                }
-
-                const keywords: Node[] = [];
-
-                forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
-                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
-                });
-
-                // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
-                // ability to "jump out" of the function, and include occurrences for both.
-                if (isFunctionBlock(owner)) {
-                    forEachReturnStatement(<Block>owner, returnStatement => {
-                        pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
-                    });
-                }
-
-                return map(keywords, getHighlightSpanForNode);
-            }
-
-            function getReturnOccurrences(returnStatement: ReturnStatement): HighlightSpan[] {
-                const func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
-
-                // If we didn't find a containing function with a block body, bail out.
-                if (!(func && hasKind(func.body, SyntaxKind.Block))) {
-                    return undefined;
-                }
-
-                const keywords: Node[] = [];
-                forEachReturnStatement(<Block>func.body, returnStatement => {
-                    pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
-                });
-
-                // Include 'throw' statements that do not occur within a try block.
-                forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
-                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
-                });
-
-                return map(keywords, getHighlightSpanForNode);
-            }
-
-            function getIfElseOccurrences(ifStatement: IfStatement): HighlightSpan[] {
-                const keywords: Node[] = [];
-
-                // Traverse upwards through all parent if-statements linked by their else-branches.
-                while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
-                    ifStatement = <IfStatement>ifStatement.parent;
-                }
-
-                // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
-                while (ifStatement) {
-                    const children = ifStatement.getChildren();
-                    pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
-
-                    // Generally the 'else' keyword is second-to-last, so we traverse backwards.
-                    for (let i = children.length - 1; i >= 0; i--) {
-                        if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
-                            break;
-                        }
-                    }
-
-                    if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
-                        break;
-                    }
-
-                    ifStatement = <IfStatement>ifStatement.elseStatement;
-                }
-
-                const result: HighlightSpan[] = [];
-
-                // We'd like to highlight else/ifs together if they are only separated by whitespace
-                // (i.e. the keywords are separated by no comments, no newlines).
-                for (let i = 0; i < keywords.length; i++) {
-                    if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
-                        const elseKeyword = keywords[i];
-                        const ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
-
-                        let shouldCombindElseAndIf = true;
-
-                        // Avoid recalculating getStart() by iterating backwards.
-                        for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
-                            if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
-                                shouldCombindElseAndIf = false;
-                                break;
-                            }
-                        }
-
-                        if (shouldCombindElseAndIf) {
-                            result.push({
-                                fileName: fileName,
-                                textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
-                                kind: HighlightSpanKind.reference
-                            });
-                            i++; // skip the next keyword
-                            continue;
-                        }
-                    }
-
-                    // Ordinary case: just highlight the keyword.
-                    result.push(getHighlightSpanForNode(keywords[i]));
-                }
-
-                return result;
+            // Do not cross function boundaries.
+            else if (!isFunctionLike(node)) {
+                forEachChild(node, aggregate);
             }
         }
     }
 
+    /**
+     * For lack of a better name, this function takes a throw statement and returns the
+     * nearest ancestor that is a try-block (whose try statement has a catch clause),
+     * function-block, or source file.
+     */
+    function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
+        let child: Node = throwStatement;
+
+        while (child.parent) {
+            const parent = child.parent;
+
+            if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
+                return parent;
+            }
+
+            // A throw-statement is only owned by a try-statement if the try-statement has
+            // a catch clause, and if the throw-statement occurs within the try block.
+            if (parent.kind === SyntaxKind.TryStatement) {
+                const tryStatement = <TryStatement>parent;
+
+                if (tryStatement.tryBlock === child && tryStatement.catchClause) {
+                    return child;
+                }
+            }
+
+            child = parent;
+        }
+
+        return undefined;
+    }
+
+    function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
+        const statementAccumulator: BreakOrContinueStatement[] = [];
+        aggregate(node);
+        return statementAccumulator;
+
+        function aggregate(node: Node): void {
+            if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
+                statementAccumulator.push(<BreakOrContinueStatement>node);
+            }
+            // Do not cross function boundaries.
+            else if (!isFunctionLike(node)) {
+                forEachChild(node, aggregate);
+            }
+        }
+    }
+
+    function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
+        const actualOwner = getBreakOrContinueOwner(statement);
+
+        return actualOwner && actualOwner === owner;
+    }
+
+    function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
+        for (let node = statement.parent; node; node = node.parent) {
+            switch (node.kind) {
+                case SyntaxKind.SwitchStatement:
+                    if (statement.kind === SyntaxKind.ContinueStatement) {
+                        continue;
+                    }
+                // Fall through.
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.WhileStatement:
+                case SyntaxKind.DoStatement:
+                    if (!statement.label || isLabeledBy(node, statement.label.text)) {
+                        return node;
+                    }
+                    break;
+                default:
+                    // Don't cross function boundaries.
+                    if (isFunctionLike(node)) {
+                        return undefined;
+                    }
+                    break;
+            }
+        }
+
+        return undefined;
+    }
+
+    function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): Node[] {
+        const container = declaration.parent;
+
+        // Make sure we only highlight the keyword when it makes sense to do so.
+        if (isAccessibilityModifier(modifier)) {
+            if (!(container.kind === SyntaxKind.ClassDeclaration ||
+                container.kind === SyntaxKind.ClassExpression ||
+                (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
+                return undefined;
+            }
+        }
+        else if (modifier === SyntaxKind.StaticKeyword) {
+            if (!(container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression)) {
+                return undefined;
+            }
+        }
+        else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
+            if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
+                return undefined;
+            }
+        }
+        else if (modifier === SyntaxKind.AbstractKeyword) {
+            if (!(container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration)) {
+                return undefined;
+            }
+        }
+        else {
+            // unsupported modifier
+            return undefined;
+        }
+
+        const keywords: Node[] = [];
+        const modifierFlag: ModifierFlags = getFlagFromModifier(modifier);
+
+        let nodes: Node[];
+        switch (container.kind) {
+            case SyntaxKind.ModuleBlock:
+            case SyntaxKind.SourceFile:
+                // Container is either a class declaration or the declaration is a classDeclaration
+                if (modifierFlag & ModifierFlags.Abstract) {
+                    nodes = (<Node[]>(<ClassDeclaration>declaration).members).concat(declaration);
+                }
+                else {
+                    nodes = (<Block>container).statements;
+                }
+                break;
+            case SyntaxKind.Constructor:
+                nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
+                    (<ClassDeclaration>container.parent).members);
+                break;
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
+                nodes = (<ClassLikeDeclaration>container).members;
+
+                // If we're an accessibility modifier, we're in an instance member and should search
+                // the constructor's parameter list for instance members as well.
+                if (modifierFlag & ModifierFlags.AccessibilityModifier) {
+                    const constructor = forEach((<ClassLikeDeclaration>container).members, member => {
+                        return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
+                    });
+
+                    if (constructor) {
+                        nodes = nodes.concat(constructor.parameters);
+                    }
+                }
+                else if (modifierFlag & ModifierFlags.Abstract) {
+                    nodes = nodes.concat(container);
+                }
+                break;
+            default:
+                Debug.fail("Invalid container kind.");
+        }
+
+        forEach(nodes, node => {
+            if (getModifierFlags(node) & modifierFlag) {
+                forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
+            }
+        });
+
+        return keywords;
+
+        function getFlagFromModifier(modifier: SyntaxKind) {
+            switch (modifier) {
+                case SyntaxKind.PublicKeyword:
+                    return ModifierFlags.Public;
+                case SyntaxKind.PrivateKeyword:
+                    return ModifierFlags.Private;
+                case SyntaxKind.ProtectedKeyword:
+                    return ModifierFlags.Protected;
+                case SyntaxKind.StaticKeyword:
+                    return ModifierFlags.Static;
+                case SyntaxKind.ExportKeyword:
+                    return ModifierFlags.Export;
+                case SyntaxKind.DeclareKeyword:
+                    return ModifierFlags.Ambient;
+                case SyntaxKind.AbstractKeyword:
+                    return ModifierFlags.Abstract;
+                default:
+                    Debug.fail();
+            }
+        }
+    }
+
+    function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
+        if (token && contains(expected, token.kind)) {
+            keywordList.push(token);
+            return true;
+        }
+
+        return false;
+    }
+
+    function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): Node[] {
+        const keywords: Node[] = [];
+
+        tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
+        tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
+
+        return keywords;
+
+        function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
+            const accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
+
+            if (accessor) {
+                forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
+            }
+        }
+    }
+
+    function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): Node[] {
+        const declarations = constructorDeclaration.symbol.getDeclarations();
+
+        const keywords: Node[] = [];
+
+        forEach(declarations, declaration => {
+            forEach(declaration.getChildren(), token => {
+                return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
+            });
+        });
+
+        return keywords;
+    }
+
+    function getLoopBreakContinueOccurrences(loopNode: IterationStatement): Node[] {
+        const keywords: Node[] = [];
+
+        if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
+            // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+            if (loopNode.kind === SyntaxKind.DoStatement) {
+                const loopTokens = loopNode.getChildren();
+
+                for (let i = loopTokens.length - 1; i >= 0; i--) {
+                    if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        const breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
+
+        forEach(breaksAndContinues, statement => {
+            if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
+            }
+        });
+
+        return keywords;
+    }
+
+    function getBreakOrContinueStatementOccurrences(breakOrContinueStatement: BreakOrContinueStatement): Node[] {
+        const owner = getBreakOrContinueOwner(breakOrContinueStatement);
+
+        if (owner) {
+            switch (owner.kind) {
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.WhileStatement:
+                    return getLoopBreakContinueOccurrences(<IterationStatement>owner);
+                case SyntaxKind.SwitchStatement:
+                    return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
+
+            }
+        }
+
+        return undefined;
+    }
+
+    function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): Node[] {
+        const keywords: Node[] = [];
+
+        pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
+
+        // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+        forEach(switchStatement.caseBlock.clauses, clause => {
+            pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
+
+            const breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
+
+            forEach(breaksAndContinues, statement => {
+                if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                    pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
+                }
+            });
+        });
+
+        return keywords;
+    }
+
+    function getTryCatchFinallyOccurrences(tryStatement: TryStatement, sourceFile: SourceFile): Node[] {
+        const keywords: Node[] = [];
+
+        pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+
+        if (tryStatement.catchClause) {
+            pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+        }
+
+        if (tryStatement.finallyBlock) {
+            const finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+            pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+        }
+
+        return keywords;
+    }
+
+    function getThrowOccurrences(throwStatement: ThrowStatement): Node[] {
+        const owner = getThrowStatementOwner(throwStatement);
+
+        if (!owner) {
+            return undefined;
+        }
+
+        const keywords: Node[] = [];
+
+        forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
+            pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+        });
+
+        // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+        // ability to "jump out" of the function, and include occurrences for both.
+        if (isFunctionBlock(owner)) {
+            forEachReturnStatement(<Block>owner, returnStatement => {
+                pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+            });
+        }
+
+        return keywords;
+    }
+
+    function getReturnOccurrences(returnStatement: ReturnStatement): Node[] {
+        const func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
+
+        // If we didn't find a containing function with a block body, bail out.
+        if (!(func && hasKind(func.body, SyntaxKind.Block))) {
+            return undefined;
+        }
+
+        const keywords: Node[] = [];
+        forEachReturnStatement(<Block>func.body, returnStatement => {
+            pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+        });
+
+        // Include 'throw' statements that do not occur within a try block.
+        forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
+            pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+        });
+
+        return keywords;
+    }
+
+    function getIfElseOccurrences(ifStatement: IfStatement, sourceFile: SourceFile): HighlightSpan[] {
+        const keywords: Node[] = [];
+
+        // Traverse upwards through all parent if-statements linked by their else-branches.
+        while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
+            ifStatement = <IfStatement>ifStatement.parent;
+        }
+
+        // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+        while (ifStatement) {
+            const children = ifStatement.getChildren();
+            pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+
+            // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+            for (let i = children.length - 1; i >= 0; i--) {
+                if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
+                    break;
+                }
+            }
+
+            if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
+                break;
+            }
+
+            ifStatement = <IfStatement>ifStatement.elseStatement;
+        }
+
+        const result: HighlightSpan[] = [];
+
+        // We'd like to highlight else/ifs together if they are only separated by whitespace
+        // (i.e. the keywords are separated by no comments, no newlines).
+        for (let i = 0; i < keywords.length; i++) {
+            if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
+                const elseKeyword = keywords[i];
+                const ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+
+                let shouldCombindElseAndIf = true;
+
+                // Avoid recalculating getStart() by iterating backwards.
+                for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
+                    if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
+                        shouldCombindElseAndIf = false;
+                        break;
+                    }
+                }
+
+                if (shouldCombindElseAndIf) {
+                    result.push({
+                        fileName: sourceFile.fileName,
+                        textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                        kind: HighlightSpanKind.reference
+                    });
+                    i++; // skip the next keyword
+                    continue;
+                }
+            }
+
+            // Ordinary case: just highlight the keyword.
+            result.push(getHighlightSpanForNode(keywords[i], sourceFile));
+        }
+
+        return result;
+    }
+
     /**
      * Whether or not a 'node' is preceded by a label of the given string.
      * Note: 'node' cannot be a SourceFile.

From b4c15982ff1caceedc496e6fbdee276a793de554 Mon Sep 17 00:00:00 2001
From: Herrington Darkholme <nonamesheep1@gmail.com>
Date: Wed, 18 Jan 2017 14:57:20 +0800
Subject: [PATCH 065/159] fix #13556: enable rest/spread on `object`

---
 src/compiler/checker.ts                            |  4 ++--
 .../nonPrimitiveAccessProperty.errors.txt          |  8 +++++++-
 .../reference/nonPrimitiveAccessProperty.js        | 14 ++++++++++++++
 tests/baselines/reference/objectSpread.js          |  4 ++++
 tests/baselines/reference/objectSpread.symbols     |  4 ++++
 tests/baselines/reference/objectSpread.types       |  7 +++++++
 .../reference/objectSpreadNegative.errors.txt      | 14 +++++++++++---
 tests/baselines/reference/objectSpreadNegative.js  |  9 +++++++++
 .../nonPrimitive/nonPrimitiveAccessProperty.ts     |  3 +++
 .../cases/conformance/types/spread/objectSpread.ts |  2 ++
 .../types/spread/objectSpreadNegative.ts           |  5 +++++
 11 files changed, 68 insertions(+), 6 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 963d2e77c1b..97ca01bc086 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -11784,7 +11784,7 @@ namespace ts {
        }
 
         function isValidSpreadType(type: Type): boolean {
-            return !!(type.flags & (TypeFlags.Any | TypeFlags.Null | TypeFlags.Undefined) ||
+            return !!(type.flags & (TypeFlags.Any | TypeFlags.Null | TypeFlags.Undefined | TypeFlags.NonPrimitive) ||
                 type.flags & TypeFlags.Object && !isGenericMappedType(type) ||
                 type.flags & TypeFlags.UnionOrIntersection && !forEach((<UnionOrIntersectionType>type).types, t => !isValidSpreadType(t)));
         }
diff --git a/tests/baselines/reference/nonPrimitiveAccessProperty.errors.txt b/tests/baselines/reference/nonPrimitiveAccessProperty.errors.txt
index 8ef94c64448..0a6dfa66b86 100644
--- a/tests/baselines/reference/nonPrimitiveAccessProperty.errors.txt
+++ b/tests/baselines/reference/nonPrimitiveAccessProperty.errors.txt
@@ -1,10 +1,16 @@
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts(3,3): error TS2339: Property 'nonExist' does not exist on type 'object'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts(5,7): error TS2459: Type 'object' has no property 'destructuring' and no string index signature.
 
 
-==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts (1 errors) ====
+==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts (2 errors) ====
     var a: object;
     a.toString();
     a.nonExist(); // error
       ~~~~~~~~
 !!! error TS2339: Property 'nonExist' does not exist on type 'object'.
+    
+    var { destructuring } = a; // error
+          ~~~~~~~~~~~~~
+!!! error TS2459: Type 'object' has no property 'destructuring' and no string index signature.
+    var { ...rest } = a; // ok
     
\ No newline at end of file
diff --git a/tests/baselines/reference/nonPrimitiveAccessProperty.js b/tests/baselines/reference/nonPrimitiveAccessProperty.js
index a71b2aba865..abfe2605e32 100644
--- a/tests/baselines/reference/nonPrimitiveAccessProperty.js
+++ b/tests/baselines/reference/nonPrimitiveAccessProperty.js
@@ -2,9 +2,23 @@
 var a: object;
 a.toString();
 a.nonExist(); // error
+
+var { destructuring } = a; // error
+var { ...rest } = a; // ok
 
 
 //// [nonPrimitiveAccessProperty.js]
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
 var a;
 a.toString();
 a.nonExist(); // error
+var destructuring = a.destructuring; // error
+var rest = __rest(a, []); // ok
diff --git a/tests/baselines/reference/objectSpread.js b/tests/baselines/reference/objectSpread.js
index 4305e17ab31..259b86628a5 100644
--- a/tests/baselines/reference/objectSpread.js
+++ b/tests/baselines/reference/objectSpread.js
@@ -78,6 +78,8 @@ let computedAfter: { a: number, b: string, "at the end": number } =
 // shortcut syntax
 let a = 12;
 let shortCutted: { a: number, b: string } = { ...o, a }
+// non primitive
+let spreadNonPrimitve = { ...<object>{}}
 
 
 
@@ -148,4 +150,6 @@ var computedAfter = __assign({}, o, (_c = { b: 'yeah' }, _c['at the end'] = 14,
 // shortcut syntax
 var a = 12;
 var shortCutted = __assign({}, o, { a: a });
+// non primitive
+var spreadNonPrimitve = __assign({}, {});
 var _a, _b, _c;
diff --git a/tests/baselines/reference/objectSpread.symbols b/tests/baselines/reference/objectSpread.symbols
index 35c10faa9c0..69c9ed34341 100644
--- a/tests/baselines/reference/objectSpread.symbols
+++ b/tests/baselines/reference/objectSpread.symbols
@@ -316,4 +316,8 @@ let shortCutted: { a: number, b: string } = { ...o, a }
 >o : Symbol(o, Decl(objectSpread.ts, 0, 3))
 >a : Symbol(a, Decl(objectSpread.ts, 78, 51))
 
+// non primitive
+let spreadNonPrimitve = { ...<object>{}}
+>spreadNonPrimitve : Symbol(spreadNonPrimitve, Decl(objectSpread.ts, 80, 3))
+
 
diff --git a/tests/baselines/reference/objectSpread.types b/tests/baselines/reference/objectSpread.types
index a571bd0bb63..8a8df1a497f 100644
--- a/tests/baselines/reference/objectSpread.types
+++ b/tests/baselines/reference/objectSpread.types
@@ -407,4 +407,11 @@ let shortCutted: { a: number, b: string } = { ...o, a }
 >o : { a: number; b: string; }
 >a : number
 
+// non primitive
+let spreadNonPrimitve = { ...<object>{}}
+>spreadNonPrimitve : { constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }
+>{ ...<object>{}} : { constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }
+><object>{} : object
+>{} : {}
+
 
diff --git a/tests/baselines/reference/objectSpreadNegative.errors.txt b/tests/baselines/reference/objectSpreadNegative.errors.txt
index 17f07bc06a2..2b0960996ff 100644
--- a/tests/baselines/reference/objectSpreadNegative.errors.txt
+++ b/tests/baselines/reference/objectSpreadNegative.errors.txt
@@ -14,11 +14,12 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(37,19): error TS269
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(42,1): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '{}' has no compatible call signatures.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(46,12): error TS2339: Property 'b' does not exist on type '{}'.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(52,9): error TS2339: Property 'm' does not exist on type '{ p: number; }'.
-tests/cases/conformance/types/spread/objectSpreadNegative.ts(56,14): error TS2698: Spread types may only be created from object types.
-tests/cases/conformance/types/spread/objectSpreadNegative.ts(59,14): error TS2698: Spread types may only be created from object types.
+tests/cases/conformance/types/spread/objectSpreadNegative.ts(57,11): error TS2339: Property 'a' does not exist on type '{ constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }'.
+tests/cases/conformance/types/spread/objectSpreadNegative.ts(61,14): error TS2698: Spread types may only be created from object types.
+tests/cases/conformance/types/spread/objectSpreadNegative.ts(64,14): error TS2698: Spread types may only be created from object types.
 
 
-==== tests/cases/conformance/types/spread/objectSpreadNegative.ts (15 errors) ====
+==== tests/cases/conformance/types/spread/objectSpreadNegative.ts (16 errors) ====
     let o = { a: 1, b: 'no' }
     
     /// private propagates
@@ -101,6 +102,13 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(59,14): error TS269
             ~
 !!! error TS2339: Property 'm' does not exist on type '{ p: number; }'.
     
+    // non primitive
+    let obj: object = { a: 123 };
+    let spreadObj = { ...obj };
+    spreadObj.a; // error 'a' is not in {}
+              ~
+!!! error TS2339: Property 'a' does not exist on type '{ constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }'.
+    
     // generics
     function f<T, U>(t: T, u: U) {
         return { ...t, ...u, id: 'id' };
diff --git a/tests/baselines/reference/objectSpreadNegative.js b/tests/baselines/reference/objectSpreadNegative.js
index dff84355370..fd834b6ef9c 100644
--- a/tests/baselines/reference/objectSpreadNegative.js
+++ b/tests/baselines/reference/objectSpreadNegative.js
@@ -52,6 +52,11 @@ let c: C = new C()
 let spreadC = { ...c }
 spreadC.m(); // error 'm' is not in '{ ... c }'
 
+// non primitive
+let obj: object = { a: 123 };
+let spreadObj = { ...obj };
+spreadObj.a; // error 'a' is not in {}
+
 // generics
 function f<T, U>(t: T, u: U) {
     return { ...t, ...u, id: 'id' };
@@ -132,6 +137,10 @@ var C = (function () {
 var c = new C();
 var spreadC = __assign({}, c);
 spreadC.m(); // error 'm' is not in '{ ... c }'
+// non primitive
+var obj = { a: 123 };
+var spreadObj = __assign({}, obj);
+spreadObj.a; // error 'a' is not in {}
 // generics
 function f(t, u) {
     return __assign({}, t, u, { id: 'id' });
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts
index 2febbb1e2ca..cf902c12e65 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts
@@ -1,3 +1,6 @@
 var a: object;
 a.toString();
 a.nonExist(); // error
+
+var { destructuring } = a; // error
+var { ...rest } = a; // ok
diff --git a/tests/cases/conformance/types/spread/objectSpread.ts b/tests/cases/conformance/types/spread/objectSpread.ts
index ebf2bdb2ade..c4562e6f196 100644
--- a/tests/cases/conformance/types/spread/objectSpread.ts
+++ b/tests/cases/conformance/types/spread/objectSpread.ts
@@ -78,4 +78,6 @@ let computedAfter: { a: number, b: string, "at the end": number } =
 // shortcut syntax
 let a = 12;
 let shortCutted: { a: number, b: string } = { ...o, a }
+// non primitive
+let spreadNonPrimitve = { ...<object>{}}
 
diff --git a/tests/cases/conformance/types/spread/objectSpreadNegative.ts b/tests/cases/conformance/types/spread/objectSpreadNegative.ts
index 6d1e0dde429..c3b42b31aa9 100644
--- a/tests/cases/conformance/types/spread/objectSpreadNegative.ts
+++ b/tests/cases/conformance/types/spread/objectSpreadNegative.ts
@@ -52,6 +52,11 @@ let c: C = new C()
 let spreadC = { ...c }
 spreadC.m(); // error 'm' is not in '{ ... c }'
 
+// non primitive
+let obj: object = { a: 123 };
+let spreadObj = { ...obj };
+spreadObj.a; // error 'a' is not in {}
+
 // generics
 function f<T, U>(t: T, u: U) {
     return { ...t, ...u, id: 'id' };

From 2d232c21a2ab611b551af967459ac6e25431f9e8 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 17 Jan 2017 10:29:54 -0800
Subject: [PATCH 066/159] Support find-all-references for type keywords

---
 src/harness/fourslash.ts                      |   6 +-
 src/services/documentHighlights.ts            |  18 +-
 src/services/findAllReferences.ts             | 191 ++++++++++--------
 src/services/services.ts                      |  31 ++-
 src/services/types.ts                         |   2 +-
 src/services/utilities.ts                     |  22 +-
 tests/cases/fourslash/findAllRefsPrimitive.ts |  33 +++
 tests/cases/fourslash/fourslash.ts            |   1 +
 tests/cases/fourslash/getOccurrencesOfAny.ts  |  12 --
 tests/cases/fourslash/localGetReferences.ts   |   6 +-
 10 files changed, 191 insertions(+), 131 deletions(-)
 create mode 100644 tests/cases/fourslash/findAllRefsPrimitive.ts
 delete mode 100644 tests/cases/fourslash/getOccurrencesOfAny.ts

diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 1afb6de2cf2..6e9ab502e52 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -1668,7 +1668,7 @@ namespace FourSlash {
             this.goToPosition(len);
         }
 
-        private goToRangeStart({fileName, start}: Range) {
+        public goToRangeStart({fileName, start}: Range) {
             this.openFile(fileName);
             this.goToPosition(start);
         }
@@ -3082,6 +3082,10 @@ namespace FourSlashInterface {
             this.state.goToMarker(name);
         }
 
+        public rangeStart(range: FourSlash.Range) {
+            this.state.goToRangeStart(range);
+        }
+
         public bof() {
             this.state.goToBOF();
         }
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 79fa0236bc5..778a007ded5 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -17,25 +17,11 @@ namespace ts.DocumentHighlights {
     }
 
     function getSemanticDocumentHighlights(node: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
-        if (node.kind === SyntaxKind.Identifier ||
-            node.kind === SyntaxKind.ThisKeyword ||
-            node.kind === SyntaxKind.ThisType ||
-            node.kind === SyntaxKind.SuperKeyword ||
-            node.kind === SyntaxKind.StringLiteral ||
-            isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
-
-            const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false, /*implementations*/false);
-            return convertReferencedSymbols(referencedSymbols);
-        }
-
-        return undefined;
+        const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/false, /*findInComments*/false, /*implementations*/false);
+        return referencedSymbols && convertReferencedSymbols(referencedSymbols);
     }
 
     function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
-        if (!referencedSymbols) {
-            return undefined;
-        }
-
         const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
         const result: DocumentHighlights[] = [];
         for (const referencedSymbol of referencedSymbols) {
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 090357a56b2..68eb684fe25 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -1,29 +1,16 @@
 /* @internal */
 namespace ts.FindAllReferences {
-    export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] {
+    export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] | undefined {
         const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
-        if (node === sourceFile) {
-            return undefined;
-        }
-
-        switch (node.kind) {
-            case SyntaxKind.NumericLiteral:
-                if (!isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
-                    break;
-                }
-                // Fallthrough
-            case SyntaxKind.Identifier:
-            case SyntaxKind.ThisKeyword:
-            // case SyntaxKind.SuperKeyword: TODO:GH#9268
-            case SyntaxKind.ConstructorKeyword:
-            case SyntaxKind.StringLiteral:
-                return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, /*implementations*/false);
-        }
-        return undefined;
+        return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, /*implementations*/false);
     }
 
-    export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean, implementations: boolean): ReferencedSymbol[] {
+    export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean, implementations: boolean): ReferencedSymbol[] | undefined {
         if (!implementations) {
+            if (isTypeKeyword(node.kind)) {
+                return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken);
+            }
+
             // Labels
             if (isLabelName(node)) {
                 if (isJumpStatementTarget(node)) {
@@ -68,8 +55,6 @@ namespace ts.FindAllReferences {
             return undefined;
         }
 
-        let result: ReferencedSymbol[];
-
         // Compute the meaning from the location and the symbol it references
         const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
 
@@ -84,6 +69,7 @@ namespace ts.FindAllReferences {
         // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
         const symbolToIndex: number[] = [];
 
+        let result: ReferencedSymbol[];
         if (scope) {
             result = [];
             getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
@@ -92,10 +78,7 @@ namespace ts.FindAllReferences {
             const internedName = getInternedName(symbol, node);
             for (const sourceFile of sourceFiles) {
                 cancellationToken.throwIfCancellationRequested();
-
-                const nameTable = getNameTable(sourceFile);
-
-                if (nameTable.get(internedName) !== undefined) {
+                if (sourceFileHasName(sourceFile, internedName)) {
                     result = result || [];
                     getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
                 }
@@ -105,9 +88,13 @@ namespace ts.FindAllReferences {
         return result;
     }
 
+    function sourceFileHasName(sourceFile: SourceFile, name: string): boolean {
+        return getNameTable(sourceFile).get(name) !== undefined;
+    }
+
     function getDefinition(symbol: Symbol, node: Node, typeChecker: TypeChecker): ReferencedSymbolDefinitionInfo {
-        const info = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node);
-        const name = map(info.displayParts, p => p.text).join("");
+        const { displayParts, symbolKind } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node);
+        const name = displayParts.map(p => p.text).join("");
         const declarations = symbol.declarations;
         if (!declarations || declarations.length === 0) {
             return undefined;
@@ -117,10 +104,10 @@ namespace ts.FindAllReferences {
             containerKind: "",
             containerName: "",
             name,
-            kind: info.symbolKind,
+            kind: symbolKind,
             fileName: declarations[0].getSourceFile().fileName,
             textSpan: createTextSpan(declarations[0].getStart(), 0),
-            displayParts: info.displayParts
+            displayParts
         };
     }
 
@@ -351,6 +338,45 @@ namespace ts.FindAllReferences {
         }
     }
 
+    function getAllReferencesForKeyword(sourceFiles: SourceFile[], keywordKind: ts.SyntaxKind, cancellationToken: CancellationToken): ReferencedSymbol[] {
+        const name = tokenToString(keywordKind);
+        const definition: ReferencedSymbolDefinitionInfo = {
+            containerKind: "",
+            containerName: "",
+            fileName: "",
+            kind: ScriptElementKind.keyword,
+            name,
+            textSpan: createTextSpan(0, 1),
+            displayParts: [{ text: name, kind: ScriptElementKind.keyword }]
+        }
+
+        const references: ReferenceEntry[] = [];
+        for (const sourceFile of sourceFiles) {
+            cancellationToken.throwIfCancellationRequested();
+            if (sourceFileHasName(sourceFile, name)) {
+                addReferencesForKeywordInFile(sourceFile, keywordKind, name, cancellationToken, references);
+            }
+        }
+
+        return [{ definition, references }];
+    }
+
+    function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, cancellationToken: CancellationToken, references: Push<ReferenceEntry>): void {
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
+        for (const position of possiblePositions) {
+            cancellationToken.throwIfCancellationRequested();
+            const referenceLocation = getTouchingPropertyName(sourceFile, position);
+            if (referenceLocation.kind === kind) {
+                references.push({
+                    textSpan: createTextSpanFromNode(referenceLocation),
+                    fileName: sourceFile.fileName,
+                    isWriteAccess: false,
+                    isDefinition: false,
+                });
+            }
+        }
+    }
+
     /** Search within node "container" for references for a search value, where the search value is defined as a
          * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning).
         * searchLocation: a node where the search value
@@ -375,67 +401,64 @@ namespace ts.FindAllReferences {
 
         const parents = getParentSymbolsOfPropertyAccess();
         const inheritsFromCache: Map<boolean> = createMap<boolean>();
+        // Build the set of symbols to search for, initially it has only the current symbol
+        const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation, typeChecker, implementations);
 
-        if (possiblePositions.length) {
-            // Build the set of symbols to search for, initially it has only the current symbol
-            const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation, typeChecker, implementations);
+        for (const position of possiblePositions) {
+            cancellationToken.throwIfCancellationRequested();
 
-            forEach(possiblePositions, position => {
-                cancellationToken.throwIfCancellationRequested();
+            const referenceLocation = getTouchingPropertyName(sourceFile, position);
+            if (!isValidReferencePosition(referenceLocation, searchText)) {
+                // This wasn't the start of a token.  Check to see if it might be a
+                // match in a comment or string if that's what the caller is asking
+                // for.
+                if (!implementations && ((findInStrings && isInString(sourceFile, position)) ||
+                    (findInComments && isInNonReferenceComment(sourceFile, position)))) {
 
-                const referenceLocation = getTouchingPropertyName(sourceFile, position);
-                if (!isValidReferencePosition(referenceLocation, searchText)) {
-                    // This wasn't the start of a token.  Check to see if it might be a
-                    // match in a comment or string if that's what the caller is asking
-                    // for.
-                    if (!implementations && ((findInStrings && isInString(sourceFile, position)) ||
-                        (findInComments && isInNonReferenceComment(sourceFile, position)))) {
-
-                        // In the case where we're looking inside comments/strings, we don't have
-                        // an actual definition.  So just use 'undefined' here.  Features like
-                        // 'Rename' won't care (as they ignore the definitions), and features like
-                        // 'FindReferences' will just filter out these results.
-                        result.push({
-                            definition: undefined,
-                            references: [{
-                                fileName: sourceFile.fileName,
-                                textSpan: createTextSpan(position, searchText.length),
-                                isWriteAccess: false,
-                                isDefinition: false
-                            }]
-                        });
-                    }
-                    return;
+                    // In the case where we're looking inside comments/strings, we don't have
+                    // an actual definition.  So just use 'undefined' here.  Features like
+                    // 'Rename' won't care (as they ignore the definitions), and features like
+                    // 'FindReferences' will just filter out these results.
+                    result.push({
+                        definition: undefined,
+                        references: [{
+                            fileName: sourceFile.fileName,
+                            textSpan: createTextSpan(position, searchText.length),
+                            isWriteAccess: false,
+                            isDefinition: false
+                        }]
+                    });
                 }
+                continue;
+            }
 
-                if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
-                    return;
+            if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
+                continue;
+            }
+
+            const referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation);
+            if (referenceSymbol) {
+                const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
+                const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
+                const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
+                    /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker);
+
+                if (relatedSymbol) {
+                    addReferenceToRelatedSymbol(referenceLocation, relatedSymbol);
                 }
-
-                const referenceSymbol = typeChecker.getSymbolAtLocation(referenceLocation);
-                if (referenceSymbol) {
-                    const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
-                    const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
-                    const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
-                        /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker);
-
-                    if (relatedSymbol) {
-                        addReferenceToRelatedSymbol(referenceLocation, relatedSymbol);
-                    }
-                    /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
-                        * has two meaning : property name and property value. Therefore when we do findAllReference at the position where
-                        * an identifier is declared, the language service should return the position of the variable declaration as well as
-                        * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
-                        * position of property accessing, the referenceEntry of such position will be handled in the first case.
-                        */
-                    else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) {
-                        addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
-                    }
-                    else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
-                        findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
-                    }
+                /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
+                    * has two meaning : property name and property value. Therefore when we do findAllReference at the position where
+                    * an identifier is declared, the language service should return the position of the variable declaration as well as
+                    * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
+                    * position of property accessing, the referenceEntry of such position will be handled in the first case.
+                    */
+                else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) {
+                    addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
                 }
-            });
+                else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
+                    findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
+                }
+            }
         }
         return;
 
diff --git a/src/services/services.ts b/src/services/services.ts
index 26374eccbfd..20204165328 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1959,11 +1959,9 @@ namespace ts {
 
         function walk(node: Node) {
             switch (node.kind) {
-                case SyntaxKind.Identifier: {
-                    const text = (<Identifier>node).text;
-                    nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
+                case SyntaxKind.Identifier:
+                    setNameTable((<Identifier>node).text, node);
                     break;
-                }
                 case SyntaxKind.StringLiteral:
                 case SyntaxKind.NumericLiteral:
                     // We want to store any numbers/strings if they were a name that could be
@@ -1974,20 +1972,31 @@ namespace ts {
                         node.parent.kind === SyntaxKind.ExternalModuleReference ||
                         isArgumentOfElementAccessExpression(node) ||
                         isLiteralComputedPropertyDeclarationName(node)) {
-
-                        const text = (<LiteralExpression>node).text;
-                        nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
+                        setNameTable((<LiteralExpression>node).text, node);
                     }
                     break;
-                default:
+                case SyntaxKind.TypeOperator:
+                    setNameTable(tokenToString((node as ts.TypeOperatorNode).operator), node);
                     forEachChild(node, walk);
-                    if (node.jsDoc) {
-                        for (const jsDoc of node.jsDoc) {
-                            forEachChild(jsDoc, walk);
+                    break;
+                default:
+                    if (isTypeKeyword(node.kind)) {
+                        setNameTable(tokenToString(node.kind), node);
+                    }
+                    else {
+                        forEachChild(node, walk);
+                        if (node.jsDoc) {
+                            for (const jsDoc of node.jsDoc) {
+                                forEachChild(jsDoc, walk);
+                            }
                         }
                     }
             }
         }
+
+        function setNameTable(text: string, node: ts.Node): void {
+            nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
+        }
     }
 
     function isArgumentOfElementAccessExpression(node: Node) {
diff --git a/src/services/types.ts b/src/services/types.ts
index 88ffe2950ce..42f2a7992bd 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -495,7 +495,7 @@ namespace ts {
 
     export interface SymbolDisplayPart {
         text: string;
-        kind: string;
+        kind: string; // A ScriptElementKind
     }
 
     export interface QuickInfo {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index def7ab8e4bd..dd337238da3 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -71,7 +71,10 @@ namespace ts {
     }
 
     export function getMeaningFromLocation(node: Node): SemanticMeaning {
-        if (node.parent.kind === SyntaxKind.ExportAssignment) {
+        if (node.kind === SyntaxKind.SourceFile) {
+            return SemanticMeaning.Value;
+        }
+        else if (node.parent.kind === SyntaxKind.ExportAssignment) {
             return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
         }
         else if (isInRightSideOfImport(node)) {
@@ -1116,6 +1119,23 @@ namespace ts {
     export function createTextSpanFromNode(node: Node, sourceFile?: SourceFile): TextSpan {
         return createTextSpanFromBounds(node.getStart(sourceFile), node.getEnd());
     }
+
+    export function isTypeKeyword(kind: SyntaxKind): boolean {
+        switch (kind) {
+            case SyntaxKind.AnyKeyword:
+            case SyntaxKind.BooleanKeyword:
+            case SyntaxKind.NeverKeyword:
+            case SyntaxKind.NumberKeyword:
+            case SyntaxKind.KeyOfKeyword:
+            case SyntaxKind.ObjectKeyword:
+            case SyntaxKind.StringKeyword:
+            case SyntaxKind.SymbolKeyword:
+            case SyntaxKind.VoidKeyword:
+                return true;
+            default:
+                return false;
+        }
+    }
 }
 
 // Display-part writer helpers
diff --git a/tests/cases/fourslash/findAllRefsPrimitive.ts b/tests/cases/fourslash/findAllRefsPrimitive.ts
new file mode 100644
index 00000000000..9bd3d62eabb
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsPrimitive.ts
@@ -0,0 +1,33 @@
+// @noLib: true
+
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////const x: [|any|] = 0;
+////const any = 2;
+////const y: [|any|] = any;
+
+////function f(b: [|boolean|]): [|boolean|];
+
+////type T = [|never|]; type U = [|never|];
+
+////function n(x: [|number|]): [|number|];
+
+////function o(x: [|object|]): [|object|];
+
+////function s(x: [|string|]): [|string|];
+
+////function sy(s: [|symbol|]): [|symbol|];
+
+////function v(v: [|void|]): [|void|];
+
+////function k(x: [|keyof|] Date): [|keyof|] Date;
+
+// @Filename: b.ts
+// const z: [|any|] = 0;
+
+verify.rangesWithSameTextReferenceEachOther();
+verify.rangesWithSameTextAreDocumentHighlights();
+
+goTo.rangeStart(test.ranges()[0]);
+verify.renameInfoFailed();
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index ed09fcd2c92..d0293585a4e 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -118,6 +118,7 @@ declare namespace FourSlashInterface {
     }
     class goTo {
         marker(name?: string): void;
+        rangeStart(range: Range): void;
         bof(): void;
         eof(): void;
         implementation(): void;
diff --git a/tests/cases/fourslash/getOccurrencesOfAny.ts b/tests/cases/fourslash/getOccurrencesOfAny.ts
deleted file mode 100644
index c28dd83b422..00000000000
--- a/tests/cases/fourslash/getOccurrencesOfAny.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-////var obj1: {
-////    (bar: any): any;
-////    new (bar: any): any;
-////    [bar: any]: any;
-////    bar: any;
-////    foob(bar: any): an/**/y;
-////};
-
-goTo.marker();
-verify.occurrencesAtPositionCount(0);
diff --git a/tests/cases/fourslash/localGetReferences.ts b/tests/cases/fourslash/localGetReferences.ts
index fa9e59cabcf..d8e64be1ada 100644
--- a/tests/cases/fourslash/localGetReferences.ts
+++ b/tests/cases/fourslash/localGetReferences.ts
@@ -3,7 +3,7 @@
 // @Filename: localGetReferences_1.ts
 ////// Comment Refence Test: g/*1*/lobalVar
 ////// References to a variable declared in global.
-////var [|globalVar|]: n/*2*/umber = 2;
+////var [|globalVar|]: number = 2;
 ////
 ////class fooCls {
 ////    // References to static variable declared in a class.
@@ -189,10 +189,6 @@
 goTo.marker("1");
 verify.referencesAre([]);
 
-// References to type.
-goTo.marker("2");
-verify.referencesAre([]);
-
 // References to unresolved symbol.
 goTo.marker("3");
 verify.referencesAre([]);

From 9665f2501158d8c765d27bd315dcace9b59d1758 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 18 Jan 2017 13:55:31 -0800
Subject: [PATCH 067/159] Simplify fourslash tests by adding some helpers

---
 src/harness/fourslash.ts                      | 72 +++++++++++++++++--
 ...tIdentifierDefinitionLocations_Generics.ts |  6 +-
 ...stAtIdentifierDefinitionLocations_catch.ts |  6 +-
 ...AtIdentifierDefinitionLocations_classes.ts |  5 +-
 ...tifierDefinitionLocations_destructuring.ts |  5 +-
 ...entifierDefinitionLocations_enumMembers.ts |  6 +-
 ...ntifierDefinitionLocations_enumMembers2.ts |  5 +-
 ...stAtIdentifierDefinitionLocations_enums.ts |  5 +-
 ...IdentifierDefinitionLocations_functions.ts |  6 +-
 ...ierDefinitionLocations_interfaceMembers.ts |  5 +-
 ...erDefinitionLocations_interfaceMembers2.ts |  5 +-
 ...erDefinitionLocations_interfaceMembers3.ts |  5 +-
 ...dentifierDefinitionLocations_interfaces.ts |  6 +-
 ...dentifierDefinitionLocations_parameters.ts |  6 +-
 ...dentifierDefinitionLocations_properties.ts |  3 +-
 ...fierDefinitionLocations_varDeclarations.ts |  5 +-
 .../completionListAtInvalidLocations.ts       |  5 +-
 ...stBuilderLocations_VariableDeclarations.ts |  9 +--
 ...mpletionListBuilderLocations_parameters.ts |  4 +-
 ...mpletionListBuilderLocations_properties.ts |  5 +-
 .../completionListInIndexSignature01.ts       |  5 +-
 .../completionListInIndexSignature02.ts       |  5 +-
 .../completionListInObjectLiteral4.ts         |  6 +-
 .../completionListInStringLiterals1.ts        |  6 +-
 .../completionListInStringLiterals2.ts        |  6 +-
 .../completionListInTemplateLiteralParts1.ts  |  6 +-
 ...ionListInTemplateLiteralPartsNegatives1.ts |  6 +-
 ...ionListNewIdentifierFunctionDeclaration.ts |  3 +-
 ...ionListNewIdentifierVariableDeclaration.ts |  5 +-
 .../docCommentTemplateInSingleLineComment.ts  |  7 +-
 ...ommentTemplateInsideFunctionDeclaration.ts |  5 +-
 .../fourslash/docCommentTemplateRegex.ts      |  5 +-
 tests/cases/fourslash/fourslash.ts            |  7 +-
 .../fourslash/getOccurrencesAbstract01.ts     | 11 +--
 .../fourslash/getOccurrencesAbstract02.ts     | 11 +--
 ...etOccurrencesClassExpressionConstructor.ts |  9 +--
 .../getOccurrencesClassExpressionPrivate.ts   |  9 +--
 .../getOccurrencesClassExpressionPublic.ts    |  9 +--
 .../getOccurrencesClassExpressionStatic.ts    | 11 +--
 ...getOccurrencesClassExpressionStaticThis.ts |  9 +--
 .../getOccurrencesClassExpressionThis.ts      |  9 +--
 .../cases/fourslash/getOccurrencesConst02.ts  |  5 +-
 .../cases/fourslash/getOccurrencesConst03.ts  |  5 +-
 .../fourslash/getOccurrencesConstructor.ts    | 12 +---
 .../fourslash/getOccurrencesConstructor2.ts   | 12 +---
 .../cases/fourslash/getOccurrencesDeclare1.ts |  9 +--
 .../cases/fourslash/getOccurrencesDeclare2.ts |  9 +--
 .../cases/fourslash/getOccurrencesDeclare3.ts |  9 +--
 .../cases/fourslash/getOccurrencesExport1.ts  |  9 +--
 .../cases/fourslash/getOccurrencesExport2.ts  |  9 +--
 .../cases/fourslash/getOccurrencesExport3.ts  |  9 +--
 tests/cases/fourslash/getOccurrencesIfElse.ts | 12 +---
 .../cases/fourslash/getOccurrencesIfElse2.ts  |  9 +--
 .../cases/fourslash/getOccurrencesIfElse3.ts  |  9 +--
 .../fourslash/getOccurrencesIfElseBroken.ts   |  8 +--
 .../fourslash/getOccurrencesIsWriteAccess.ts  |  8 +--
 .../getOccurrencesLoopBreakContinue.ts        | 15 ++--
 .../getOccurrencesLoopBreakContinue2.ts       | 15 ++--
 .../getOccurrencesLoopBreakContinue3.ts       | 15 ++--
 .../getOccurrencesLoopBreakContinue4.ts       | 15 ++--
 .../getOccurrencesLoopBreakContinue5.ts       | 15 ++--
 .../getOccurrencesLoopBreakContinue6.ts       |  8 +--
 ...etOccurrencesLoopBreakContinueNegatives.ts |  8 +--
 .../getOccurrencesModifiersNegatives1.ts      |  6 +-
 .../getOccurrencesOfAnonymousFunction.ts      | 10 +--
 .../cases/fourslash/getOccurrencesPrivate1.ts |  9 +--
 .../cases/fourslash/getOccurrencesPrivate2.ts |  9 +--
 ...etOccurrencesPropertyInAliasedInterface.ts |  8 +--
 .../fourslash/getOccurrencesProtected1.ts     |  9 +--
 .../fourslash/getOccurrencesProtected2.ts     |  9 +--
 .../cases/fourslash/getOccurrencesPublic1.ts  |  9 +--
 .../cases/fourslash/getOccurrencesPublic2.ts  |  9 +--
 tests/cases/fourslash/getOccurrencesReturn.ts | 12 +---
 .../cases/fourslash/getOccurrencesReturn2.ts  | 12 +---
 .../cases/fourslash/getOccurrencesReturn3.ts  |  8 +--
 .../fourslash/getOccurrencesReturnBroken.ts   | 10 +--
 .../fourslash/getOccurrencesSetAndGet.ts      | 10 +--
 .../fourslash/getOccurrencesSetAndGet2.ts     | 10 +--
 .../fourslash/getOccurrencesSetAndGet3.ts     | 10 +--
 .../cases/fourslash/getOccurrencesStatic1.ts  |  9 +--
 .../getOccurrencesStringLiteralTypes.ts       |  9 +--
 .../fourslash/getOccurrencesStringLiterals.ts |  6 +-
 tests/cases/fourslash/getOccurrencesSuper.ts  | 14 ++--
 tests/cases/fourslash/getOccurrencesSuper2.ts | 14 ++--
 tests/cases/fourslash/getOccurrencesSuper3.ts |  2 +-
 .../fourslash/getOccurrencesSuperNegatives.ts |  6 +-
 .../getOccurrencesSwitchCaseDefault.ts        | 10 +--
 .../getOccurrencesSwitchCaseDefault2.ts       | 10 +--
 .../getOccurrencesSwitchCaseDefault3.ts       |  9 +--
 .../getOccurrencesSwitchCaseDefault4.ts       | 15 +---
 tests/cases/fourslash/getOccurrencesThis.ts   | 14 ++--
 tests/cases/fourslash/getOccurrencesThis2.ts  | 14 ++--
 tests/cases/fourslash/getOccurrencesThis3.ts  | 14 ++--
 tests/cases/fourslash/getOccurrencesThis4.ts  | 14 ++--
 tests/cases/fourslash/getOccurrencesThis5.ts  | 14 ++--
 .../fourslash/getOccurrencesThisNegatives2.ts |  8 +--
 tests/cases/fourslash/getOccurrencesThrow.ts  | 16 ++---
 tests/cases/fourslash/getOccurrencesThrow2.ts | 16 ++---
 tests/cases/fourslash/getOccurrencesThrow3.ts | 16 ++---
 tests/cases/fourslash/getOccurrencesThrow4.ts | 16 ++---
 tests/cases/fourslash/getOccurrencesThrow5.ts | 16 ++---
 tests/cases/fourslash/getOccurrencesThrow6.ts | 13 +---
 tests/cases/fourslash/getOccurrencesThrow7.ts | 11 +--
 tests/cases/fourslash/getOccurrencesThrow8.ts | 11 +--
 .../fourslash/quickInfoInvalidLocations.ts    | 10 +--
 .../fourslash/referencesForIndexProperty2.ts  |  4 +-
 tests/cases/fourslash/referencesInComment.ts  |  4 +-
 tests/cases/fourslash/renameAlias.ts          |  6 +-
 tests/cases/fourslash/renameAlias2.ts         |  6 +-
 tests/cases/fourslash/renameAlias3.ts         |  6 +-
 .../fourslash/renameAliasExternalModule.ts    |  7 +-
 .../fourslash/renameAliasExternalModule2.ts   |  7 +-
 .../fourslash/renameAliasExternalModule3.ts   |  7 +-
 .../renameContextuallyTypedProperties.ts      |  7 +-
 .../renameContextuallyTypedProperties2.ts     |  7 +-
 tests/cases/fourslash/renameDefaultImport.ts  | 23 +++---
 .../renameDefaultImportDifferentName.ts       | 24 +++----
 .../renameDestructuringAssignment.ts          | 16 ++---
 .../renameDestructuringAssignmentInFor2.ts    | 26 +++----
 .../renameDestructuringAssignmentInForOf2.ts  | 26 +++----
 ...ucturingAssignmentNestedInArrayLiteral2.ts | 20 +++---
 ...nameDestructuringAssignmentNestedInFor2.ts | 13 ++--
 ...meDestructuringAssignmentNestedInForOf2.ts | 14 ++--
 .../renameDestructuringClassProperty.ts       | 14 ++--
 .../renameDestructuringDeclarationInFor.ts    | 26 +++----
 .../renameDestructuringDeclarationInForOf.ts  | 24 +++----
 .../renameDestructuringFunctionParameter.ts   | 11 ++-
 ...renameDestructuringNestedBindingElement.ts | 14 ++--
 .../fourslash/renameForDefaultExport01.ts     |  7 +-
 .../fourslash/renameForDefaultExport02.ts     |  7 +-
 .../fourslash/renameForDefaultExport03.ts     |  7 +-
 .../cases/fourslash/renameImportAndExport.ts  |  6 +-
 .../fourslash/renameImportAndShorthand.ts     |  6 +-
 .../renameImportNamespaceAndShorthand.ts      |  6 +-
 .../fourslash/renameImportOfExportEquals.ts   |  6 +-
 tests/cases/fourslash/renameImportRequire.ts  | 12 ++--
 .../fourslash/renameInheritedProperties1.ts   |  7 +-
 .../fourslash/renameInheritedProperties2.ts   |  7 +-
 .../fourslash/renameInheritedProperties3.ts   |  7 +-
 .../fourslash/renameInheritedProperties4.ts   |  7 +-
 .../fourslash/renameInheritedProperties5.ts   |  8 +--
 .../fourslash/renameInheritedProperties6.ts   |  7 +-
 .../fourslash/renameInheritedProperties7.ts   | 11 +--
 .../fourslash/renameInheritedProperties8.ts   | 11 +--
 .../renameLocationsForClassExpression01.ts    |  8 +--
 .../renameLocationsForFunctionExpression01.ts |  7 +-
 .../renameLocationsForFunctionExpression02.ts |  9 +--
 ...enameObjectBindingElementPropertyName01.ts |  5 +-
 tests/cases/fourslash/renameObjectSpread.ts   |  6 +-
 .../fourslash/renameObjectSpreadAssignment.ts | 10 +--
 .../renameParameterPropertyDeclaration1.ts    |  7 +-
 .../renameParameterPropertyDeclaration2.ts    |  7 +-
 .../renameParameterPropertyDeclaration3.ts    |  7 +-
 .../renameParameterPropertyDeclaration4.ts    |  7 +-
 .../renameParameterPropertyDeclaration5.ts    |  7 +-
 tests/cases/fourslash/renameRest.ts           |  8 +--
 .../fourslash/renameStingPropertyNames.ts     |  7 +-
 .../fourslash/renameStringLiteralTypes.ts     |  6 +-
 tests/cases/fourslash/renameThis.ts           |  4 +-
 .../cases/fourslash/renameUMDModuleAlias1.ts  |  6 +-
 tests/cases/fourslash/server/occurrences01.ts | 11 +--
 tests/cases/fourslash/server/occurrences02.ts | 11 +--
 .../signatureHelpTaggedTemplates1.ts          |  6 +-
 .../signatureHelpTaggedTemplates2.ts          |  6 +-
 .../signatureHelpTaggedTemplates3.ts          |  6 +-
 .../signatureHelpTaggedTemplates4.ts          |  6 +-
 .../signatureHelpTaggedTemplates5.ts          |  6 +-
 .../signatureHelpTaggedTemplates6.ts          |  6 +-
 .../signatureHelpTaggedTemplates7.ts          |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete1.ts |  8 +--
 ...signatureHelpTaggedTemplatesIncomplete2.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete3.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete4.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete5.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete6.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete7.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete8.ts |  6 +-
 ...signatureHelpTaggedTemplatesIncomplete9.ts |  6 +-
 .../signatureHelpTaggedTemplatesNegatives1.ts |  7 +-
 .../signatureHelpTaggedTemplatesNegatives2.ts |  7 +-
 .../signatureHelpTaggedTemplatesNegatives3.ts |  7 +-
 .../signatureHelpTaggedTemplatesNegatives4.ts |  7 +-
 .../signatureHelpTaggedTemplatesNegatives5.ts |  7 +-
 .../signatureHelpTaggedTemplatesNested1.ts    |  6 +-
 .../signatureHelpTaggedTemplatesNested2.ts    |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags1.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags2.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags3.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags4.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags5.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags6.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags7.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags8.ts |  6 +-
 ...eHelpTaggedTemplatesWithOverloadedTags9.ts |  8 +--
 .../completionListGenericConstraintsNames.ts  |  9 ++-
 195 files changed, 482 insertions(+), 1301 deletions(-)

diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 1afb6de2cf2..721647df0cd 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -372,8 +372,8 @@ namespace FourSlash {
         }
 
         // Entry points from fourslash.ts
-        public goToMarker(name = "") {
-            const marker = this.getMarkerByName(name);
+        public goToMarker(name: string | Marker = "") {
+            const marker = typeof name === "string" ? this.getMarkerByName(name) : name;
             if (this.activeFile.fileName !== marker.fileName) {
                 this.openFile(marker.fileName);
             }
@@ -382,10 +382,37 @@ namespace FourSlash {
             if (marker.position === -1 || marker.position > content.length) {
                 throw new Error(`Marker "${name}" has been invalidated by unrecoverable edits to the file.`);
             }
-            this.lastKnownMarker = name;
+            const mName = typeof name === "string" ? name : this.markerName(marker);
+            this.lastKnownMarker = mName;
             this.goToPosition(marker.position);
         }
 
+        public goToEachMarker(action: () => void) {
+            const markers = this.getMarkers();
+            assert(markers.length);
+            for (const marker of markers) {
+                this.goToMarker(marker);
+                action();
+            }
+        }
+
+        public goToEachRange(action: () => void) {
+            const ranges = this.getRanges();
+            assert(ranges.length);
+            for (const range of ranges) {
+                this.goToRangeStart(range);
+                action();
+            }
+        }
+
+        private markerName(m: Marker): string {
+            return ts.forEachEntry(this.testData.markerPositions, (marker, name) => {
+                if (marker === m) {
+                    return name;
+                }
+            })!;
+        }
+
         public goToPosition(pos: number) {
             this.currentCaretPosition = pos;
         }
@@ -1668,7 +1695,7 @@ namespace FourSlash {
             this.goToPosition(len);
         }
 
-        private goToRangeStart({fileName, start}: Range) {
+        public goToRangeStart({fileName, start}: Range) {
             this.openFile(fileName);
             this.goToPosition(start);
         }
@@ -2365,6 +2392,21 @@ namespace FourSlash {
             return this.languageService.getDocumentHighlights(this.activeFile.fileName, this.currentCaretPosition, filesToSearch);
         }
 
+        public verifyRangesAreOccurrences(isWriteAccess?: boolean) {
+            const ranges = this.getRanges();
+            for (const r of ranges) {
+                this.goToRangeStart(r);
+                this.verifyOccurrencesAtPositionListCount(ranges.length);
+                for (const range of ranges) {
+                    this.verifyOccurrencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess);
+                }
+            }
+        }
+
+        public verifyRangesAreRenameLocations(findInStrings: boolean, findInComments: boolean) {
+            this.goToEachRange(() => this.verifyRenameLocations(findInStrings, findInComments));
+        }
+
         public verifyRangesWithSameTextAreDocumentHighlights() {
             this.rangesByText().forEach(ranges => this.verifyRangesAreDocumentHighlights(ranges));
         }
@@ -3078,10 +3120,22 @@ namespace FourSlashInterface {
         // Moves the caret to the specified marker,
         // or the anonymous marker ('/**/') if no name
         // is given
-        public marker(name?: string) {
+        public marker(name?: string | FourSlash.Marker) {
             this.state.goToMarker(name);
         }
 
+        public eachMarker(action: () => void) {
+            this.state.goToEachMarker(action);
+        }
+
+        public rangeStart(range: FourSlash.Range) {
+            this.state.goToRangeStart(range);
+        }
+
+        public eachRange(action: () => void) {
+            this.state.goToEachRange(action);
+        }
+
         public bof() {
             this.state.goToBOF();
         }
@@ -3432,6 +3486,14 @@ namespace FourSlashInterface {
             this.state.verifyOccurrencesAtPositionListCount(expectedCount);
         }
 
+        public rangesAreOccurrences(isWriteAccess?: boolean) {
+            this.state.verifyRangesAreOccurrences(isWriteAccess);
+        }
+
+        public rangesAreRenameLocations(findInStrings = false, findInComments = false) {
+            this.state.verifyRangesAreRenameLocations(findInStrings, findInComments);
+        }
+
         public rangesAreDocumentHighlights(ranges?: FourSlash.Range[]) {
             this.state.verifyRangesAreDocumentHighlights(ranges);
         }
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_Generics.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_Generics.ts
index 0e92a3ae995..784fc8c499c 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_Generics.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_Generics.ts
@@ -11,8 +11,4 @@
 
 ////function A</*genericName5*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_catch.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_catch.ts
index bdf13c1d97f..bfbfa1bb160 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_catch.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_catch.ts
@@ -6,8 +6,4 @@
 
 //// try {} catch(a/*catchVariable2*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_classes.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_classes.ts
index 60a108cf1e6..5d96c565719 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_classes.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_classes.ts
@@ -6,7 +6,4 @@
 
 ////class a/*className2*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_destructuring.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_destructuring.ts
index 7f8ef32e1ad..d2ecdf29426 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_destructuring.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_destructuring.ts
@@ -16,7 +16,4 @@
 
 //// function func2({ a, b/*parameter2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers.ts
index 6c0472be546..f0818108301 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers.ts
@@ -4,8 +4,4 @@
 
 ////enum a { /*enumValueName1*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers2.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers2.ts
index ee2f3e71032..11aa276bb5a 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers2.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enumMembers2.ts
@@ -3,7 +3,4 @@
 ////var aa = 1;
 ////enum a { foo, /*enumValueName3*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enums.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enums.ts
index 183f8a22c63..c740218e27e 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enums.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_enums.ts
@@ -8,7 +8,4 @@
 
 ////var x = 0; enum /*enumName4*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_functions.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_functions.ts
index 24231174727..2f55f9527bc 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_functions.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_functions.ts
@@ -6,8 +6,4 @@
 
 ////function a/*functionName2*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers.ts
index 266b0b78c9c..9998f38c255 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers.ts
@@ -4,7 +4,4 @@
 
 ////interface a { /*interfaceValue1*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers2.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers2.ts
index 82a30325948..234e41bfb71 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers2.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers2.ts
@@ -4,7 +4,4 @@
 
 ////interface a { f/*interfaceValue2*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers3.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers3.ts
index ed640dd3f1a..f0a596ef8b1 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers3.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaceMembers3.ts
@@ -4,7 +4,4 @@
 
 ////interface a { f; /*interfaceValue3*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaces.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaces.ts
index ec2732fe2fe..d4be268eb7d 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaces.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_interfaces.ts
@@ -6,8 +6,4 @@
 
 ////interface a/*interfaceName2*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_parameters.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_parameters.ts
index 10293c41a64..474859129db 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_parameters.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_parameters.ts
@@ -22,8 +22,4 @@
 
 ////class bar10{ constructor(...a/*constructorParamter6*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_properties.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_properties.ts
index 58fdc1d2342..3ba0df0c31d 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_properties.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_properties.ts
@@ -30,8 +30,7 @@
 ////    private a/*property7*/
 ////}
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
+goTo.eachMarker(() => {
     verify.not.completionListIsEmpty();
     verify.completionListAllowsNewIdentifier();
 });
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_varDeclarations.ts b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_varDeclarations.ts
index 2e85364ce3c..9a2c9ba664a 100644
--- a/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_varDeclarations.ts
+++ b/tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_varDeclarations.ts
@@ -11,7 +11,4 @@
 
 ////var a2, a/*varName4*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListAtInvalidLocations.ts b/tests/cases/fourslash/completionListAtInvalidLocations.ts
index 6e4b4056a7d..0660f0e183b 100644
--- a/tests/cases/fourslash/completionListAtInvalidLocations.ts
+++ b/tests/cases/fourslash/completionListAtInvalidLocations.ts
@@ -25,7 +25,4 @@
 ////foo;
 ////var v10 = /reg/*inRegExp1*/ex/;
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts b/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
index d069b9a722e..2562b840995 100644
--- a/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
+++ b/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
@@ -11,7 +11,7 @@
 //// var y : any = "", x = (a/*var5*/
 
 ////class C{}
-////var y = new C( 
+////var y = new C(
 
 //// class C{}
 //// var y = new C(0, /*var7*/
@@ -26,9 +26,4 @@
 
 ////var y = 10; y=/*var12*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListAllowsNewIdentifier();
-});
-
-
+goTo.eachMarker(() => verify.completionListAllowsNewIdentifier());
diff --git a/tests/cases/fourslash/completionListBuilderLocations_parameters.ts b/tests/cases/fourslash/completionListBuilderLocations_parameters.ts
index 12dba953d3d..607ca0d9819 100644
--- a/tests/cases/fourslash/completionListBuilderLocations_parameters.ts
+++ b/tests/cases/fourslash/completionListBuilderLocations_parameters.ts
@@ -14,9 +14,7 @@
 
 ////class bar7{ constructor(private a, /*constructorParamter6*/
 
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
+goTo.eachMarker(() => {
     verify.not.completionListIsEmpty();
     verify.completionListAllowsNewIdentifier();
 });
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionListBuilderLocations_properties.ts b/tests/cases/fourslash/completionListBuilderLocations_properties.ts
index 287ffd6746b..806d8c1de4f 100644
--- a/tests/cases/fourslash/completionListBuilderLocations_properties.ts
+++ b/tests/cases/fourslash/completionListBuilderLocations_properties.ts
@@ -10,7 +10,4 @@
 ////    public static a/*property2*/
 ////}
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.completionListIsEmpty();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListInIndexSignature01.ts b/tests/cases/fourslash/completionListInIndexSignature01.ts
index 2db28505b3e..aaf97fee1a5 100644
--- a/tests/cases/fourslash/completionListInIndexSignature01.ts
+++ b/tests/cases/fourslash/completionListInIndexSignature01.ts
@@ -14,7 +14,4 @@
 ////    [x/*5*/yz: number]: boolean;
 ////    [/*6*/
 
-for (let marker of test.markers()) {
-    goTo.position(marker.position);
-    verify.completionListAllowsNewIdentifier();
-}
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListAllowsNewIdentifier());
diff --git a/tests/cases/fourslash/completionListInIndexSignature02.ts b/tests/cases/fourslash/completionListInIndexSignature02.ts
index d3b65dc7759..ce1f8b38e24 100644
--- a/tests/cases/fourslash/completionListInIndexSignature02.ts
+++ b/tests/cases/fourslash/completionListInIndexSignature02.ts
@@ -13,7 +13,4 @@
 ////type T = {
 ////    [xyz: /*5*/
 
-for (let marker of test.markers()) {
-    goTo.position(marker.position);
-    verify.not.completionListAllowsNewIdentifier();
-}
\ No newline at end of file
+goTo.eachMarker(() => verify.not.completionListAllowsNewIdentifier());
diff --git a/tests/cases/fourslash/completionListInObjectLiteral4.ts b/tests/cases/fourslash/completionListInObjectLiteral4.ts
index c00462c8255..3094b4db6ad 100644
--- a/tests/cases/fourslash/completionListInObjectLiteral4.ts
+++ b/tests/cases/fourslash/completionListInObjectLiteral4.ts
@@ -20,9 +20,7 @@
 ////funcE({ /*E*/ });
 ////funcF({ /*F*/ });
 
-
-for (const marker of test.markers()) {
-    goTo.position(marker.position);
+goTo.eachMarker(() => {
     verify.completionListContains("hello");
     verify.completionListContains("world");
-}
+});
diff --git a/tests/cases/fourslash/completionListInStringLiterals1.ts b/tests/cases/fourslash/completionListInStringLiterals1.ts
index e394e8dfe7c..aabcc82eba5 100644
--- a/tests/cases/fourslash/completionListInStringLiterals1.ts
+++ b/tests/cases/fourslash/completionListInStringLiterals1.ts
@@ -3,8 +3,4 @@
 ////"/*1*/       /*2*/\/*3*/
 //// /*4*/   \\/*5*/
 
-test.markers().forEach(marker => {
-    goTo.position(marker.position);
-
-    verify.completionListIsEmpty()
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListInStringLiterals2.ts b/tests/cases/fourslash/completionListInStringLiterals2.ts
index 10cb05a4f91..4ffd5eb8a9b 100644
--- a/tests/cases/fourslash/completionListInStringLiterals2.ts
+++ b/tests/cases/fourslash/completionListInStringLiterals2.ts
@@ -4,8 +4,4 @@
 //// /*4*/   \\\/*5*/
 //// /*6*/
 
-test.markers().forEach(marker => {
-    goTo.position(marker.position);
-
-    verify.completionListIsEmpty()
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts b/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts
index 0166546f63e..9de7b6a6a5b 100644
--- a/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts
+++ b/tests/cases/fourslash/completionListInTemplateLiteralParts1.ts
@@ -4,8 +4,4 @@
 ////
 /////*6*/`asdasd${/*7*/ 2 + 1.1 /*8*/} 12312 {
 
-test.markers().forEach(marker => {
-    goTo.position(marker.position);
-
-    verify.completionListItemsCountIsGreaterThan(0)
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListItemsCountIsGreaterThan(0));
diff --git a/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts b/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts
index ac64a41fb56..30af0678e7d 100644
--- a/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts
+++ b/tests/cases/fourslash/completionListInTemplateLiteralPartsNegatives1.ts
@@ -4,8 +4,4 @@
 ////
 ////`asdasd$/*7*/{ 2 + 1.1 }/*8*/ 12312 /*9*/{/*10*/
 
-test.markers().forEach(marker => {
-    goTo.position(marker.position);
-
-    verify.completionListIsEmpty()
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.completionListIsEmpty());
diff --git a/tests/cases/fourslash/completionListNewIdentifierFunctionDeclaration.ts b/tests/cases/fourslash/completionListNewIdentifierFunctionDeclaration.ts
index 8a9a5bfb9ed..1f8b24d1cf1 100644
--- a/tests/cases/fourslash/completionListNewIdentifierFunctionDeclaration.ts
+++ b/tests/cases/fourslash/completionListNewIdentifierFunctionDeclaration.ts
@@ -2,8 +2,7 @@
 
 ////function F(pref: (a/*1*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
+goTo.eachMarker(() => {
     verify.not.completionListIsEmpty();
     verify.completionListAllowsNewIdentifier();
 });
diff --git a/tests/cases/fourslash/completionListNewIdentifierVariableDeclaration.ts b/tests/cases/fourslash/completionListNewIdentifierVariableDeclaration.ts
index 534011b7ee1..a4126ebe8be 100644
--- a/tests/cases/fourslash/completionListNewIdentifierVariableDeclaration.ts
+++ b/tests/cases/fourslash/completionListNewIdentifierVariableDeclaration.ts
@@ -4,8 +4,7 @@
 
 ////var y : (s:string, list/*2*/
 
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
+goTo.eachMarker(() => {
     verify.not.completionListIsEmpty();
     verify.completionListAllowsNewIdentifier();
-});
\ No newline at end of file
+});
diff --git a/tests/cases/fourslash/docCommentTemplateInSingleLineComment.ts b/tests/cases/fourslash/docCommentTemplateInSingleLineComment.ts
index 52925870a66..65e9c17014e 100644
--- a/tests/cases/fourslash/docCommentTemplateInSingleLineComment.ts
+++ b/tests/cases/fourslash/docCommentTemplateInSingleLineComment.ts
@@ -3,12 +3,9 @@
 // @Filename: justAComment.ts
 //// // We want to check off-by-one errors in assessing the end of the comment, so we check twice,
 //// // first with a trailing space and then without.
-//// // /*0*/ 
+//// // /*0*/
 //// // /*1*/
 //// // We also want to check EOF handling at the end of a comment
 //// // /*2*/
 
-test.markers().forEach((marker) => {
-    goTo.position(marker.position);
-    verify.noDocCommentTemplate();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.noDocCommentTemplate());
diff --git a/tests/cases/fourslash/docCommentTemplateInsideFunctionDeclaration.ts b/tests/cases/fourslash/docCommentTemplateInsideFunctionDeclaration.ts
index 9c803301526..dd58a1bfd5f 100644
--- a/tests/cases/fourslash/docCommentTemplateInsideFunctionDeclaration.ts
+++ b/tests/cases/fourslash/docCommentTemplateInsideFunctionDeclaration.ts
@@ -3,7 +3,4 @@
 // @Filename: functionDecl.ts
 ////f/*0*/unction /*1*/foo/*2*/(/*3*/) /*4*/{ /*5*/}
 
-test.markers().forEach((marker) => {
-    goTo.position(marker.position);
-    verify.noDocCommentTemplate();
-});
+goTo.eachMarker(() => verify.noDocCommentTemplate());
diff --git a/tests/cases/fourslash/docCommentTemplateRegex.ts b/tests/cases/fourslash/docCommentTemplateRegex.ts
index 0bf50f5e85a..62d200dee10 100644
--- a/tests/cases/fourslash/docCommentTemplateRegex.ts
+++ b/tests/cases/fourslash/docCommentTemplateRegex.ts
@@ -3,7 +3,4 @@
 // @Filename: regex.ts
 ////var regex = /*0*///*1*/asdf/*2*/ /*3*///*4*/;
 
-test.markers().forEach((marker) => {
-    goTo.position(marker.position);
-    verify.noDocCommentTemplate();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.noDocCommentTemplate());
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index ed09fcd2c92..6685bbc19c0 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -117,7 +117,10 @@ declare namespace FourSlashInterface {
         markerByName(s: string): Marker;
     }
     class goTo {
-        marker(name?: string): void;
+        marker(name?: string | Marker): void;
+        eachMarker(action: () => void): void;
+        rangeStart(range: Range): void;
+        eachRange(action: () => void): void;
         bof(): void;
         eof(): void;
         implementation(): void;
@@ -191,6 +194,8 @@ declare namespace FourSlashInterface {
          * `start` should be included in `references`.
          */
         referencesOf(start: Range, references: Range[]): void;
+        rangesAreOccurrences(isWriteAccess?: boolean): void;
+        rangesAreRenameLocations(findInStrings?: boolean, findInComments?: boolean): void;
         /**
          * Performs `referencesOf` for every range on the whole set.
          * If `ranges` is omitted, this is `test.ranges()`.
diff --git a/tests/cases/fourslash/getOccurrencesAbstract01.ts b/tests/cases/fourslash/getOccurrencesAbstract01.ts
index 3e48ba4841a..b2ccc815e05 100644
--- a/tests/cases/fourslash/getOccurrencesAbstract01.ts
+++ b/tests/cases/fourslash/getOccurrencesAbstract01.ts
@@ -12,13 +12,4 @@
 ////    abstract bar(): void;
 ////}
 
-const ranges = test.ranges();
-
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(ranges.length);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesAbstract02.ts b/tests/cases/fourslash/getOccurrencesAbstract02.ts
index 8daafdbdc8e..1decdaaf69c 100644
--- a/tests/cases/fourslash/getOccurrencesAbstract02.ts
+++ b/tests/cases/fourslash/getOccurrencesAbstract02.ts
@@ -11,16 +11,7 @@
 ////    abstract bar(): void;
 ////}
 
-const ranges = test.ranges();
-
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(ranges.length);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
 
 goTo.marker("1");
 verify.occurrencesAtPositionCount(0);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionConstructor.ts b/tests/cases/fourslash/getOccurrencesClassExpressionConstructor.ts
index 5fa778ef8cd..d092c1dfd92 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionConstructor.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionConstructor.ts
@@ -13,11 +13,4 @@
 ////    }
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionPrivate.ts b/tests/cases/fourslash/getOccurrencesClassExpressionPrivate.ts
index b008ec237b8..2bc18d2eb25 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionPrivate.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionPrivate.ts
@@ -17,11 +17,4 @@
 ////    public test2() {}
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionPublic.ts b/tests/cases/fourslash/getOccurrencesClassExpressionPublic.ts
index 3070fd4f6ca..c54dbd289e0 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionPublic.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionPublic.ts
@@ -17,11 +17,4 @@
 ////    public test2() {}
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionStatic.ts b/tests/cases/fourslash/getOccurrencesClassExpressionStatic.ts
index 567c0c4eccd..d4851ad86ef 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionStatic.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionStatic.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
 ////let A = class Foo {
-////    public static foo;
+////    public [|static|] foo;
 ////    [|static|] a;
 ////    constructor(public y: string, private x: string) {
 ////    }
@@ -19,11 +19,4 @@
 ////    public static test2() {}
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts b/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
index 5444ab9acdd..53c1a69bead 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionStaticThis.ts
@@ -46,11 +46,4 @@
 ////    }
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts b/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts
index ed8f8cb1d0e..d1331e54a43 100644
--- a/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts
+++ b/tests/cases/fourslash/getOccurrencesClassExpressionThis.ts
@@ -44,11 +44,4 @@
 ////    }
 ////}
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesConst02.ts b/tests/cases/fourslash/getOccurrencesConst02.ts
index 0dc96fcca6c..57d75f88e22 100644
--- a/tests/cases/fourslash/getOccurrencesConst02.ts
+++ b/tests/cases/fourslash/getOccurrencesConst02.ts
@@ -10,7 +10,4 @@
 ////declare [|const|] enum E {
 ////}
 
-test.ranges().forEach(range => {
-    goTo.position(range.start);
-    verify.occurrencesAtPositionCount(0);
-});
\ No newline at end of file
+goTo.eachRange(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesConst03.ts b/tests/cases/fourslash/getOccurrencesConst03.ts
index 404ff655044..a86481ed72a 100644
--- a/tests/cases/fourslash/getOccurrencesConst03.ts
+++ b/tests/cases/fourslash/getOccurrencesConst03.ts
@@ -10,7 +10,4 @@
 ////export [|const|] enum E {
 ////}
 
-test.ranges().forEach(range => {
-    goTo.position(range.start);
-    verify.occurrencesAtPositionCount(0);
-});
\ No newline at end of file
+goTo.eachRange(() => verify.occurrencesAtPositionCount(0));
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesConstructor.ts b/tests/cases/fourslash/getOccurrencesConstructor.ts
index 0a6b84a5770..41d72c533a3 100644
--- a/tests/cases/fourslash/getOccurrencesConstructor.ts
+++ b/tests/cases/fourslash/getOccurrencesConstructor.ts
@@ -18,15 +18,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesConstructor2.ts b/tests/cases/fourslash/getOccurrencesConstructor2.ts
index 049c25b7f52..b34ffa4a190 100644
--- a/tests/cases/fourslash/getOccurrencesConstructor2.ts
+++ b/tests/cases/fourslash/getOccurrencesConstructor2.ts
@@ -18,15 +18,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesDeclare1.ts b/tests/cases/fourslash/getOccurrencesDeclare1.ts
index 4207a92b5a6..96114d3fc9d 100644
--- a/tests/cases/fourslash/getOccurrencesDeclare1.ts
+++ b/tests/cases/fourslash/getOccurrencesDeclare1.ts
@@ -53,11 +53,4 @@
 ////    [|declare|] function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesDeclare2.ts b/tests/cases/fourslash/getOccurrencesDeclare2.ts
index 3d719e5d035..78028d94996 100644
--- a/tests/cases/fourslash/getOccurrencesDeclare2.ts
+++ b/tests/cases/fourslash/getOccurrencesDeclare2.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesDeclare3.ts b/tests/cases/fourslash/getOccurrencesDeclare3.ts
index 2dee0af4b14..8c1bf7e9658 100644
--- a/tests/cases/fourslash/getOccurrencesDeclare3.ts
+++ b/tests/cases/fourslash/getOccurrencesDeclare3.ts
@@ -61,11 +61,4 @@
 ////[|declare|] module dm { }
 ////export class EC { }
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesExport1.ts b/tests/cases/fourslash/getOccurrencesExport1.ts
index bc82e8a1bea..71202a820a7 100644
--- a/tests/cases/fourslash/getOccurrencesExport1.ts
+++ b/tests/cases/fourslash/getOccurrencesExport1.ts
@@ -53,11 +53,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesExport2.ts b/tests/cases/fourslash/getOccurrencesExport2.ts
index a8e43e744b9..442642d77ec 100644
--- a/tests/cases/fourslash/getOccurrencesExport2.ts
+++ b/tests/cases/fourslash/getOccurrencesExport2.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesExport3.ts b/tests/cases/fourslash/getOccurrencesExport3.ts
index 215cbf8f48a..04ee55bb1e6 100644
--- a/tests/cases/fourslash/getOccurrencesExport3.ts
+++ b/tests/cases/fourslash/getOccurrencesExport3.ts
@@ -61,11 +61,4 @@
 ////declare module dm { }
 ////[|export|] class EC { }
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesIfElse.ts b/tests/cases/fourslash/getOccurrencesIfElse.ts
index 96c70d404ab..9251a59d130 100644
--- a/tests/cases/fourslash/getOccurrencesIfElse.ts
+++ b/tests/cases/fourslash/getOccurrencesIfElse.ts
@@ -22,15 +22,9 @@
 ////}
 ////[|else|] { }
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesIfElse2.ts b/tests/cases/fourslash/getOccurrencesIfElse2.ts
index 012e7a96efd..df77687aac6 100644
--- a/tests/cases/fourslash/getOccurrencesIfElse2.ts
+++ b/tests/cases/fourslash/getOccurrencesIfElse2.ts
@@ -22,11 +22,4 @@
 ////}
 ////else { }
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
\ No newline at end of file
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesIfElse3.ts b/tests/cases/fourslash/getOccurrencesIfElse3.ts
index b0ca3615648..aec1a6911af 100644
--- a/tests/cases/fourslash/getOccurrencesIfElse3.ts
+++ b/tests/cases/fourslash/getOccurrencesIfElse3.ts
@@ -22,11 +22,4 @@
 ////}
 ////else { }
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
\ No newline at end of file
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesIfElseBroken.ts b/tests/cases/fourslash/getOccurrencesIfElseBroken.ts
index a9e1e94f42d..c5460b3e634 100644
--- a/tests/cases/fourslash/getOccurrencesIfElseBroken.ts
+++ b/tests/cases/fourslash/getOccurrencesIfElseBroken.ts
@@ -12,13 +12,7 @@
 // It would be nice if in the future,
 // We could include that last 'else'.
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
 verify.occurrencesAtPositionCount(2);
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesIsWriteAccess.ts b/tests/cases/fourslash/getOccurrencesIsWriteAccess.ts
index 1ba4c39041c..e31b199217f 100644
--- a/tests/cases/fourslash/getOccurrencesIsWriteAccess.ts
+++ b/tests/cases/fourslash/getOccurrencesIsWriteAccess.ts
@@ -18,10 +18,8 @@
 ////[|{| "isWriteAccess": true |}x|] += 1;
 ////[|{| "isWriteAccess": true |}x|] <<= 1;
 
+goTo.rangeStart(test.ranges()[0]);
 
-var firstRange = test.ranges()[0];
-goTo.position(firstRange.start, firstRange.fileName);
-
-test.ranges().forEach((range) => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, range.marker.data.isWriteAccess);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue.ts
index 81aaaed5c58..88621cd4cf4 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    break label1;
 ////                    continue label1;
@@ -63,17 +63,10 @@
 ////
 ////label7: while (true) continue label5;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
 verify.occurrencesAtPositionCount(test.ranges().length);
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue2.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue2.ts
index 51d4d89b657..225346f8077 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue2.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue2.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    break label1;
 ////                    continue label1;
@@ -63,17 +63,10 @@
 ////
 ////label7: while (true) continue label5;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
 verify.occurrencesAtPositionCount(test.ranges().length);
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue3.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue3.ts
index 8777c912afd..c1aeef315f9 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue3.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue3.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    break label1;
 ////                    continue label1;
@@ -63,16 +63,9 @@
 ////
 ////label7: while (true) continue label5;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue4.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue4.ts
index 1bca62ba013..b183b2b3fde 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue4.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue4.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            [|continue|];
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    break label1;
 ////                    continue label1;
@@ -63,17 +63,10 @@
 ////
 ////label7: while (true) continue label5;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
 verify.occurrencesAtPositionCount(test.ranges().length);
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue5.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue5.ts
index f4e62c554e4..3353d6c96dc 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue5.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue5.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    break label1;
 ////                    continue label1;
@@ -63,17 +63,10 @@
 ////
 ////label7: while (true) continue label5;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
 verify.occurrencesAtPositionCount(test.ranges().length);
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinue6.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinue6.ts
index 0127245dd50..957f8c4af01 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinue6.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinue6.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    br/*5*/eak label1;
 ////                    co/*6*/ntinue label1;
@@ -63,8 +63,4 @@
 ////
 ////label7: while (true) co/*10*/ntinue label5;
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
-    verify.occurrencesAtPositionCount(0);
-});
+goTo.eachMarker(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesLoopBreakContinueNegatives.ts b/tests/cases/fourslash/getOccurrencesLoopBreakContinueNegatives.ts
index 0127245dd50..957f8c4af01 100644
--- a/tests/cases/fourslash/getOccurrencesLoopBreakContinueNegatives.ts
+++ b/tests/cases/fourslash/getOccurrencesLoopBreakContinueNegatives.ts
@@ -46,7 +46,7 @@
 ////                        default:
 ////                            continue;
 ////                    }
-////                    
+////
 ////                    // these cross function boundaries
 ////                    br/*5*/eak label1;
 ////                    co/*6*/ntinue label1;
@@ -63,8 +63,4 @@
 ////
 ////label7: while (true) co/*10*/ntinue label5;
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
-    verify.occurrencesAtPositionCount(0);
-});
+goTo.eachMarker(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesModifiersNegatives1.ts b/tests/cases/fourslash/getOccurrencesModifiersNegatives1.ts
index 51d5907a5d6..836d87fa9be 100644
--- a/tests/cases/fourslash/getOccurrencesModifiersNegatives1.ts
+++ b/tests/cases/fourslash/getOccurrencesModifiersNegatives1.ts
@@ -34,8 +34,4 @@
 ////[|public|] [|static|] [|protected|] [|private|] f;
 ////[|protected|] [|static|] [|public|] g;
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(0);
-});
+goTo.eachRange(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesOfAnonymousFunction.ts b/tests/cases/fourslash/getOccurrencesOfAnonymousFunction.ts
index 96354df6b05..8ce60b21306 100644
--- a/tests/cases/fourslash/getOccurrencesOfAnonymousFunction.ts
+++ b/tests/cases/fourslash/getOccurrencesOfAnonymousFunction.ts
@@ -5,12 +5,4 @@
 ////    return 0;
 ////})
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(2);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range);
-    });
-});
\ No newline at end of file
+verify.rangesAreOccurrences();
diff --git a/tests/cases/fourslash/getOccurrencesPrivate1.ts b/tests/cases/fourslash/getOccurrencesPrivate1.ts
index 991ed3ea31c..bb601451507 100644
--- a/tests/cases/fourslash/getOccurrencesPrivate1.ts
+++ b/tests/cases/fourslash/getOccurrencesPrivate1.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesPrivate2.ts b/tests/cases/fourslash/getOccurrencesPrivate2.ts
index 19397443af5..914db1a15a9 100644
--- a/tests/cases/fourslash/getOccurrencesPrivate2.ts
+++ b/tests/cases/fourslash/getOccurrencesPrivate2.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesPropertyInAliasedInterface.ts b/tests/cases/fourslash/getOccurrencesPropertyInAliasedInterface.ts
index 87ec260601b..3a9078cfc63 100644
--- a/tests/cases/fourslash/getOccurrencesPropertyInAliasedInterface.ts
+++ b/tests/cases/fourslash/getOccurrencesPropertyInAliasedInterface.ts
@@ -15,11 +15,5 @@
 ////}
 ////
 ////(new C()).[|abc|];
-test.ranges().forEach(r => {
-    goTo.position(r.start);
 
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range);
-    });
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
\ No newline at end of file
+verify.rangesAreOccurrences();
diff --git a/tests/cases/fourslash/getOccurrencesProtected1.ts b/tests/cases/fourslash/getOccurrencesProtected1.ts
index af9e3302968..b5b3442ec00 100644
--- a/tests/cases/fourslash/getOccurrencesProtected1.ts
+++ b/tests/cases/fourslash/getOccurrencesProtected1.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesProtected2.ts b/tests/cases/fourslash/getOccurrencesProtected2.ts
index 666736eee16..365d78dc9f6 100644
--- a/tests/cases/fourslash/getOccurrencesProtected2.ts
+++ b/tests/cases/fourslash/getOccurrencesProtected2.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesPublic1.ts b/tests/cases/fourslash/getOccurrencesPublic1.ts
index a451a70c1cb..1ecc816dac5 100644
--- a/tests/cases/fourslash/getOccurrencesPublic1.ts
+++ b/tests/cases/fourslash/getOccurrencesPublic1.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesPublic2.ts b/tests/cases/fourslash/getOccurrencesPublic2.ts
index b4887e18e80..6d5b4e53c0e 100644
--- a/tests/cases/fourslash/getOccurrencesPublic2.ts
+++ b/tests/cases/fourslash/getOccurrencesPublic2.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesReturn.ts b/tests/cases/fourslash/getOccurrencesReturn.ts
index 613e1645fb5..44b3679ba2e 100644
--- a/tests/cases/fourslash/getOccurrencesReturn.ts
+++ b/tests/cases/fourslash/getOccurrencesReturn.ts
@@ -19,15 +19,9 @@
 ////    [|return|] true;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesReturn2.ts b/tests/cases/fourslash/getOccurrencesReturn2.ts
index 15a062433fe..750648838a2 100644
--- a/tests/cases/fourslash/getOccurrencesReturn2.ts
+++ b/tests/cases/fourslash/getOccurrencesReturn2.ts
@@ -19,15 +19,9 @@
 ////    return true;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesReturn3.ts b/tests/cases/fourslash/getOccurrencesReturn3.ts
index 030d700ef6e..ee739efef39 100644
--- a/tests/cases/fourslash/getOccurrencesReturn3.ts
+++ b/tests/cases/fourslash/getOccurrencesReturn3.ts
@@ -19,10 +19,4 @@
 ////    return true;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
\ No newline at end of file
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesReturnBroken.ts b/tests/cases/fourslash/getOccurrencesReturnBroken.ts
index 2327a62d12c..c8d7fad0635 100644
--- a/tests/cases/fourslash/getOccurrencesReturnBroken.ts
+++ b/tests/cases/fourslash/getOccurrencesReturnBroken.ts
@@ -26,17 +26,11 @@
 ////    r/*4*/eturn 8675309;
 ////}
 
-// Note: For this test, these 'return's get highlighted as a result of a parse recovery 
+// Note: For this test, these 'return's get highlighted as a result of a parse recovery
 //       where if an arrow function starts with a statement, we try to parse a body
 //       as if it was missing curly braces. If the behavior changes in the future,
 //       a change to this test is very much welcome.
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 for (var i = 1; i <= test.markers().length; i++) {
     goTo.marker("" + i);
diff --git a/tests/cases/fourslash/getOccurrencesSetAndGet.ts b/tests/cases/fourslash/getOccurrencesSetAndGet.ts
index ddeaf8f26ff..2d28328800c 100644
--- a/tests/cases/fourslash/getOccurrencesSetAndGet.ts
+++ b/tests/cases/fourslash/getOccurrencesSetAndGet.ts
@@ -23,12 +23,4 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesSetAndGet2.ts b/tests/cases/fourslash/getOccurrencesSetAndGet2.ts
index 3e05f511efc..541efc80509 100644
--- a/tests/cases/fourslash/getOccurrencesSetAndGet2.ts
+++ b/tests/cases/fourslash/getOccurrencesSetAndGet2.ts
@@ -23,12 +23,4 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesSetAndGet3.ts b/tests/cases/fourslash/getOccurrencesSetAndGet3.ts
index 777a62db6a5..32c4d72c1a5 100644
--- a/tests/cases/fourslash/getOccurrencesSetAndGet3.ts
+++ b/tests/cases/fourslash/getOccurrencesSetAndGet3.ts
@@ -23,12 +23,4 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesStatic1.ts b/tests/cases/fourslash/getOccurrencesStatic1.ts
index 8be9862d5ec..d853f16017d 100644
--- a/tests/cases/fourslash/getOccurrencesStatic1.ts
+++ b/tests/cases/fourslash/getOccurrencesStatic1.ts
@@ -54,11 +54,4 @@
 ////    declare function foo(): string;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesStringLiteralTypes.ts b/tests/cases/fourslash/getOccurrencesStringLiteralTypes.ts
index 56af87497d5..a115ee82211 100644
--- a/tests/cases/fourslash/getOccurrencesStringLiteralTypes.ts
+++ b/tests/cases/fourslash/getOccurrencesStringLiteralTypes.ts
@@ -3,11 +3,4 @@
 ////function foo(a: "[|option 1|]") { }
 ////foo("[|option 1|]");
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, false);
-    }
-}
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesStringLiterals.ts b/tests/cases/fourslash/getOccurrencesStringLiterals.ts
index 827828acd24..cf17481e0eb 100644
--- a/tests/cases/fourslash/getOccurrencesStringLiterals.ts
+++ b/tests/cases/fourslash/getOccurrencesStringLiterals.ts
@@ -3,8 +3,4 @@
 ////var x = "[|string|]";
 ////function f(a = "[|initial value|]") { }
 
-const ranges = test.ranges();
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(1);
-}
+goTo.eachRange(() => verify.occurrencesAtPositionCount(1));
diff --git a/tests/cases/fourslash/getOccurrencesSuper.ts b/tests/cases/fourslash/getOccurrencesSuper.ts
index f53d9aca62e..6f5c51715f3 100644
--- a/tests/cases/fourslash/getOccurrencesSuper.ts
+++ b/tests/cases/fourslash/getOccurrencesSuper.ts
@@ -27,7 +27,7 @@
 ////
 ////    public method3() {
 ////        var x = () => [|super|].superMethod();
-////        
+////
 ////        // Bad but still gets highlighted
 ////        function f() {
 ////            [|super|].superMethod();
@@ -50,15 +50,9 @@
 ////    static super = 20;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesSuper2.ts b/tests/cases/fourslash/getOccurrencesSuper2.ts
index 1392170ae18..2da702acbc6 100644
--- a/tests/cases/fourslash/getOccurrencesSuper2.ts
+++ b/tests/cases/fourslash/getOccurrencesSuper2.ts
@@ -27,7 +27,7 @@
 ////
 ////    public method3() {
 ////        var x = () => super.superMethod();
-////        
+////
 ////        // Bad but still gets highlighted
 ////        function f() {
 ////            super.superMethod();
@@ -50,15 +50,9 @@
 ////    static super = 20;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesSuper3.ts b/tests/cases/fourslash/getOccurrencesSuper3.ts
index bceac02a392..88275975004 100644
--- a/tests/cases/fourslash/getOccurrencesSuper3.ts
+++ b/tests/cases/fourslash/getOccurrencesSuper3.ts
@@ -14,7 +14,7 @@
 ////}
 
 function checkRange(r: FourSlashInterface.Range, expectedOccurences: FourSlashInterface.Range[]): void {
-    goTo.position(r.start);
+    goTo.rangeStart(r);
     if (expectedOccurences.length) {
         for (const expected of expectedOccurences) {
             verify.occurrencesAtPositionContains(expected);
diff --git a/tests/cases/fourslash/getOccurrencesSuperNegatives.ts b/tests/cases/fourslash/getOccurrencesSuperNegatives.ts
index 8c76da33c12..e2bb248efc4 100644
--- a/tests/cases/fourslash/getOccurrencesSuperNegatives.ts
+++ b/tests/cases/fourslash/getOccurrencesSuperNegatives.ts
@@ -20,8 +20,4 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    verify.occurrencesAtPositionCount(0);
-});
+goTo.eachRange(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault.ts b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault.ts
index f32ff0e8f82..34f9ebcd112 100644
--- a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault.ts
+++ b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault.ts
@@ -18,12 +18,4 @@
 ////    [|case|] 16:
 ////}
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault2.ts b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault2.ts
index dd4577faa1f..1f265f079f8 100644
--- a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault2.ts
+++ b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault2.ts
@@ -18,12 +18,4 @@
 ////    case 16:
 ////}
 
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault3.ts b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault3.ts
index 24330ca1912..887e17c2b29 100644
--- a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault3.ts
+++ b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault3.ts
@@ -16,11 +16,4 @@
 ////        [|break|];
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault4.ts b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault4.ts
index 039009746dd..38b3fbfc7dd 100644
--- a/tests/cases/fourslash/getOccurrencesSwitchCaseDefault4.ts
+++ b/tests/cases/fourslash/getOccurrencesSwitchCaseDefault4.ts
@@ -10,16 +10,5 @@
 ////        contin/*2*/ue foo;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(test.ranges().length);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
-
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.occurrencesAtPositionCount(0);
-});
\ No newline at end of file
+verify.rangesAreOccurrences(false);
+goTo.eachMarker(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesThis.ts b/tests/cases/fourslash/getOccurrencesThis.ts
index e4b059b9cf9..156fde2c4ac 100644
--- a/tests/cases/fourslash/getOccurrencesThis.ts
+++ b/tests/cases/fourslash/getOccurrencesThis.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = this.staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        this;
 ////        this;
@@ -140,15 +140,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesThis2.ts b/tests/cases/fourslash/getOccurrencesThis2.ts
index 3df30369e3e..9a40eb39fb0 100644
--- a/tests/cases/fourslash/getOccurrencesThis2.ts
+++ b/tests/cases/fourslash/getOccurrencesThis2.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = this.staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        this;
 ////        this;
@@ -140,15 +140,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesThis3.ts b/tests/cases/fourslash/getOccurrencesThis3.ts
index 7ee18a31286..66c80241e4a 100644
--- a/tests/cases/fourslash/getOccurrencesThis3.ts
+++ b/tests/cases/fourslash/getOccurrencesThis3.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = this.staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        this;
 ////        this;
@@ -140,15 +140,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesThis4.ts b/tests/cases/fourslash/getOccurrencesThis4.ts
index 75a9383f88e..42ddd7984a8 100644
--- a/tests/cases/fourslash/getOccurrencesThis4.ts
+++ b/tests/cases/fourslash/getOccurrencesThis4.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = this.staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        this;
 ////        this;
@@ -140,15 +140,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesThis5.ts b/tests/cases/fourslash/getOccurrencesThis5.ts
index 86ce16b16be..845e8342fa5 100644
--- a/tests/cases/fourslash/getOccurrencesThis5.ts
+++ b/tests/cases/fourslash/getOccurrencesThis5.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = [|this|].staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        [|this|];
 ////        [|this|];
@@ -140,15 +140,9 @@
 ////    }
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/getOccurrencesThisNegatives2.ts b/tests/cases/fourslash/getOccurrencesThisNegatives2.ts
index 0a8b5860feb..3f840e8311a 100644
--- a/tests/cases/fourslash/getOccurrencesThisNegatives2.ts
+++ b/tests/cases/fourslash/getOccurrencesThisNegatives2.ts
@@ -89,7 +89,7 @@
 ////    }
 ////
 ////    public static staticB = this.staticMethod1;
-////    
+////
 ////    public static staticMethod1() {
 ////        this;
 ////        this;
@@ -140,8 +140,4 @@
 ////    }
 ////}
 
-
-test.markers().forEach(m => {
-    goTo.position(m.position, m.fileName)
-    verify.occurrencesAtPositionCount(0);
-});
+goTo.eachMarker(() => verify.occurrencesAtPositionCount(0));
diff --git a/tests/cases/fourslash/getOccurrencesThrow.ts b/tests/cases/fourslash/getOccurrencesThrow.ts
index 19f10dbfb9f..db80e3c51a0 100644
--- a/tests/cases/fourslash/getOccurrencesThrow.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow.ts
@@ -3,7 +3,7 @@
 ////function f(a: number) {
 ////    try {
 ////        throw "Hello";
-////        
+////
 ////        try {
 ////            throw 10;
 ////        }
@@ -42,17 +42,9 @@
 ////    [|throw|] false;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesThrow2.ts b/tests/cases/fourslash/getOccurrencesThrow2.ts
index 9bd2f82e638..21425990e2f 100644
--- a/tests/cases/fourslash/getOccurrencesThrow2.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow2.ts
@@ -3,7 +3,7 @@
 ////function f(a: number) {
 ////    try {
 ////        throw "Hello";
-////        
+////
 ////        try {
 ////            [|t/**/hrow|] 10;
 ////        }
@@ -42,17 +42,9 @@
 ////    throw false;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesThrow3.ts b/tests/cases/fourslash/getOccurrencesThrow3.ts
index 359b783df07..d601123f7bd 100644
--- a/tests/cases/fourslash/getOccurrencesThrow3.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow3.ts
@@ -3,7 +3,7 @@
 ////function f(a: number) {
 ////    try {
 ////        [|throw|] "Hello";
-////        
+////
 ////        try {
 ////            throw 10;
 ////        }
@@ -42,17 +42,9 @@
 ////    throw false;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesThrow4.ts b/tests/cases/fourslash/getOccurrencesThrow4.ts
index ab2375907ee..c348685b4ed 100644
--- a/tests/cases/fourslash/getOccurrencesThrow4.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow4.ts
@@ -3,7 +3,7 @@
 ////function f(a: number) {
 ////    try {
 ////        throw "Hello";
-////        
+////
 ////        try {
 ////            throw 10;
 ////        }
@@ -42,17 +42,9 @@
 ////    throw false;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesThrow5.ts b/tests/cases/fourslash/getOccurrencesThrow5.ts
index 9ba28191752..b4b51b677bc 100644
--- a/tests/cases/fourslash/getOccurrencesThrow5.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow5.ts
@@ -3,7 +3,7 @@
 ////function f(a: number) {
 ////    try {
 ////        throw "Hello";
-////        
+////
 ////        try {
 ////            throw 10;
 ////        }
@@ -42,17 +42,9 @@
 ////    throw false;
 ////}
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
+verify.rangesAreOccurrences(false);
 
 goTo.marker();
-test.ranges().forEach(range => {
+for (const range of test.ranges()) {
     verify.occurrencesAtPositionContains(range, false);
-});
+}
diff --git a/tests/cases/fourslash/getOccurrencesThrow6.ts b/tests/cases/fourslash/getOccurrencesThrow6.ts
index 8b58347ed8a..21509659cd8 100644
--- a/tests/cases/fourslash/getOccurrencesThrow6.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow6.ts
@@ -14,15 +14,4 @@
 ////    [|throw|] 300;
 ////}
 
-
-
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
-
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesThrow7.ts b/tests/cases/fourslash/getOccurrencesThrow7.ts
index 48ab981d762..7a35daeb775 100644
--- a/tests/cases/fourslash/getOccurrencesThrow7.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow7.ts
@@ -19,13 +19,4 @@
 ////
 ////[|throw|] 10;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
-
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/getOccurrencesThrow8.ts b/tests/cases/fourslash/getOccurrencesThrow8.ts
index cc527720dc4..0e57520d492 100644
--- a/tests/cases/fourslash/getOccurrencesThrow8.ts
+++ b/tests/cases/fourslash/getOccurrencesThrow8.ts
@@ -19,13 +19,4 @@
 ////
 ////throw 10;
 
-test.ranges().forEach(r => {
-    goTo.position(r.start);
-
-    test.ranges().forEach(range => {
-        verify.occurrencesAtPositionContains(range, false);
-    });
-
-    verify.occurrencesAtPositionCount(test.ranges().length);
-});
-
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/quickInfoInvalidLocations.ts b/tests/cases/fourslash/quickInfoInvalidLocations.ts
index 81845e27672..c70be23f387 100644
--- a/tests/cases/fourslash/quickInfoInvalidLocations.ts
+++ b/tests/cases/fourslash/quickInfoInvalidLocations.ts
@@ -27,13 +27,13 @@
 ////
 ////mod/*invlaid10*/ule m1 {
 ////    va/*invlaid11*/r varibale = 0;
-////    
+////
 ////    func/*invlaid12*/tion foo(arg1: number) {
 ////        ret/*invlaid13*/urn string;
 ////    }
 ////
 ////    class foo {
-////    
+////
 ////    }
 ////
 ////    var object = {
@@ -44,9 +44,5 @@
 ////    };
 ////}
 
-
-test.markers().forEach((marker) => {
-    goTo.position(marker.position, marker.fileName);
-    verify.not.quickInfoExists();
-});
+goTo.eachMarker(() => verify.not.quickInfoExists());
 
diff --git a/tests/cases/fourslash/referencesForIndexProperty2.ts b/tests/cases/fourslash/referencesForIndexProperty2.ts
index 0aa099c9622..35c9d7cdd64 100644
--- a/tests/cases/fourslash/referencesForIndexProperty2.ts
+++ b/tests/cases/fourslash/referencesForIndexProperty2.ts
@@ -5,6 +5,4 @@
 ////var a;
 ////a["[|blah|]"];
 
-goTo.position(test.ranges()[0].start, test.ranges()[0].fileName);
-verify.referencesAre(test.ranges());
-
+verify.rangesReferenceEachOther();
diff --git a/tests/cases/fourslash/referencesInComment.ts b/tests/cases/fourslash/referencesInComment.ts
index c53a2e6d9b3..eabf74d2f23 100644
--- a/tests/cases/fourslash/referencesInComment.ts
+++ b/tests/cases/fourslash/referencesInComment.ts
@@ -5,6 +5,4 @@
 ////class foo { }
 ////var bar = 0;
 
-for (const marker of test.markers()) {
-    verify.referencesAre([]);
-}
+goTo.eachMarker(() => verify.referencesAre([]));
diff --git a/tests/cases/fourslash/renameAlias.ts b/tests/cases/fourslash/renameAlias.ts
index e0408af656f..3869b1522b5 100644
--- a/tests/cases/fourslash/renameAlias.ts
+++ b/tests/cases/fourslash/renameAlias.ts
@@ -4,8 +4,4 @@
 ////import [|M|] = SomeModule;
 ////import C = [|M|].SomeClass;
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameAlias2.ts b/tests/cases/fourslash/renameAlias2.ts
index da1bcf8248d..f97121f5f7d 100644
--- a/tests/cases/fourslash/renameAlias2.ts
+++ b/tests/cases/fourslash/renameAlias2.ts
@@ -4,8 +4,4 @@
 ////import M = [|SomeModule|];
 ////import C = M.SomeClass;
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameAlias3.ts b/tests/cases/fourslash/renameAlias3.ts
index 9172f052abb..af3bafef115 100644
--- a/tests/cases/fourslash/renameAlias3.ts
+++ b/tests/cases/fourslash/renameAlias3.ts
@@ -4,8 +4,4 @@
 ////import M = SomeModule;
 ////import C = M.[|SomeClass|];
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameAliasExternalModule.ts b/tests/cases/fourslash/renameAliasExternalModule.ts
index 54277fd6e64..49cc6396717 100644
--- a/tests/cases/fourslash/renameAliasExternalModule.ts
+++ b/tests/cases/fourslash/renameAliasExternalModule.ts
@@ -8,9 +8,4 @@
 ////import [|M|] = require("./a");
 ////import C = [|M|].SomeClass;
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameAliasExternalModule2.ts b/tests/cases/fourslash/renameAliasExternalModule2.ts
index 2d9d07efb68..35916295a8e 100644
--- a/tests/cases/fourslash/renameAliasExternalModule2.ts
+++ b/tests/cases/fourslash/renameAliasExternalModule2.ts
@@ -8,9 +8,4 @@
 ////import M = require("./a");
 ////import C = M.SomeClass;
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameAliasExternalModule3.ts b/tests/cases/fourslash/renameAliasExternalModule3.ts
index acff9371c77..53b28e7983e 100644
--- a/tests/cases/fourslash/renameAliasExternalModule3.ts
+++ b/tests/cases/fourslash/renameAliasExternalModule3.ts
@@ -8,9 +8,4 @@
 ////import M = require("./a");
 ////import C = M.[|SomeClass|];
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameContextuallyTypedProperties.ts b/tests/cases/fourslash/renameContextuallyTypedProperties.ts
index 4feed49256f..4ce3c2b0738 100644
--- a/tests/cases/fourslash/renameContextuallyTypedProperties.ts
+++ b/tests/cases/fourslash/renameContextuallyTypedProperties.ts
@@ -55,9 +55,4 @@
 ////    set ["prop2"](v) { }
 ////};
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameContextuallyTypedProperties2.ts b/tests/cases/fourslash/renameContextuallyTypedProperties2.ts
index 1887c7751a5..01e638395a0 100644
--- a/tests/cases/fourslash/renameContextuallyTypedProperties2.ts
+++ b/tests/cases/fourslash/renameContextuallyTypedProperties2.ts
@@ -55,9 +55,4 @@
 ////    set ["[|prop2|]"](v) { }
 ////};
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDefaultImport.ts b/tests/cases/fourslash/renameDefaultImport.ts
index fd9534e65f7..8d9b65d78d6 100644
--- a/tests/cases/fourslash/renameDefaultImport.ts
+++ b/tests/cases/fourslash/renameDefaultImport.ts
@@ -1,19 +1,14 @@
 /// <reference path='fourslash.ts' />
 
-// @Filename: B.ts
-////export default class [|B|] {
-////    test() {
-////    }
-////}
+// @Filename: B.ts
+////export default class [|B|] {
+////    test() {
+////    }
+////}
 
-// @Filename: A.ts
-////import [|B|] from "./B";
-////let b = new [|B|]();
+// @Filename: A.ts
+////import [|B|] from "./B";
+////let b = new [|B|]();
 ////b.test();
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.file(range.fileName);
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDefaultImportDifferentName.ts b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
index 5965f1a63e9..aec699aadda 100644
--- a/tests/cases/fourslash/renameDefaultImportDifferentName.ts
+++ b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
@@ -1,23 +1,17 @@
 /// <reference path='fourslash.ts' />
 
-// @Filename: B.ts
-////export default class /*1*/C {
-////    test() {
-////    }
-////}
+// @Filename: B.ts
+////export default class /*1*/C {
+////    test() {
+////    }
+////}
 
-// @Filename: A.ts
-////import [|B|] from "./B";
-////let b = new [|B|]();
+// @Filename: A.ts
+////import [|B|] from "./B";
+////let b = new [|B|]();
 ////b.test();
 
-goTo.file("B.ts");
 goTo.marker("1");
 verify.occurrencesAtPositionCount(1);
 
-goTo.file("A.ts");
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignment.ts b/tests/cases/fourslash/renameDestructuringAssignment.ts
index b7b18f661d2..89a44a3a9d9 100644
--- a/tests/cases/fourslash/renameDestructuringAssignment.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignment.ts
@@ -1,14 +1,10 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    [|x|]: number;
-////}
-////var a: I;
-////var x;
+////interface I {
+////    [|x|]: number;
+////}
+////var a: I;
+////var x;
 ////({ [|x|]: x } = a);
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInFor2.ts b/tests/cases/fourslash/renameDestructuringAssignmentInFor2.ts
index ca75e42394b..4d79b47a267 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentInFor2.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentInFor2.ts
@@ -1,20 +1,16 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    property1: number;
-////    property2: string;
-////}
-////var elems: I[];
-////
-////var p2: number, [|property1|]: number;
-////for ({ [|property1|] } = elems[0]; p2 < 100; p2++) {
-////   p2 = [|property1|]++;
+////interface I {
+////    property1: number;
+////    property2: string;
 ////}
-////for ({ property1: p2 } = elems[0]; p2 < 100; p2++) {
+////var elems: I[];
+////
+////var p2: number, [|property1|]: number;
+////for ({ [|property1|] } = elems[0]; p2 < 100; p2++) {
+////   p2 = [|property1|]++;
+////}
+////for ({ property1: p2 } = elems[0]; p2 < 100; p2++) {
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInForOf2.ts b/tests/cases/fourslash/renameDestructuringAssignmentInForOf2.ts
index 401b6776d2e..9987a17d36e 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentInForOf2.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentInForOf2.ts
@@ -1,20 +1,16 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    property1: number;
-////    property2: string;
-////}
-////var elems: I[];
-////
-////var [|property1|]: number, p2: number;
-////for ({ [|property1|] } of elems) {
-////    [|property1|]++;
+////interface I {
+////    property1: number;
+////    property2: string;
 ////}
-////for ({ property1: p2 } of elems) {
+////var elems: I[];
+////
+////var [|property1|]: number, p2: number;
+////for ({ [|property1|] } of elems) {
+////    [|property1|]++;
+////}
+////for ({ property1: p2 } of elems) {
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral2.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral2.ts
index c4db2de512f..e45ae3349a4 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral2.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral2.ts
@@ -1,15 +1,11 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    property1: number;
-////    property2: string;
-////}
-////var elems: I[], p1: number, [|property1|]: number;
-////[{ property1: p1 }] = elems;
-////[{ [|property1|] }] = elems;
+////interface I {
+////    property1: number;
+////    property2: string;
+////}
+////var elems: I[], p1: number, [|property1|]: number;
+////[{ property1: p1 }] = elems;
+////[{ [|property1|] }] = elems;
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor2.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor2.ts
index 89dc899c5bf..2ec7d906ad1 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor2.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor2.ts
@@ -1,5 +1,5 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface MultiRobot {
 ////    name: string;
 ////    skills: {
@@ -14,10 +14,5 @@
 ////for ({ skills: { [|primary|], secondary } } = multiRobot, i = 0; i < 1; i++) {
 ////    console.log([|primary|]);
 ////}
-
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
-
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf2.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf2.ts
index b684e6b6a81..5364cffebb9 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf2.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf2.ts
@@ -1,5 +1,5 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface MultiRobot {
 ////    name: string;
 ////    skills: {
@@ -14,10 +14,6 @@
 ////for ({ skills: { [|primary|], secondary } } of multiRobots) {
 ////    console.log([|primary|]);
 ////}
-
-
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringClassProperty.ts b/tests/cases/fourslash/renameDestructuringClassProperty.ts
index acc58f999c4..11261a4df78 100644
--- a/tests/cases/fourslash/renameDestructuringClassProperty.ts
+++ b/tests/cases/fourslash/renameDestructuringClassProperty.ts
@@ -1,5 +1,5 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////class A {
 ////    [|foo|]: string;
 ////}
@@ -14,10 +14,6 @@
 ////        let { [|foo|] } = a;
 ////        [|foo|] = "newString";
 ////    }
-////}
-
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+////}
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringDeclarationInFor.ts b/tests/cases/fourslash/renameDestructuringDeclarationInFor.ts
index 0edf9085092..0338433ae72 100644
--- a/tests/cases/fourslash/renameDestructuringDeclarationInFor.ts
+++ b/tests/cases/fourslash/renameDestructuringDeclarationInFor.ts
@@ -1,20 +1,16 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    [|property1|]: number;
-////    property2: string;
-////}
-////var elems: I[];
-////
-////var p2: number, property1: number;
-////for (let { [|property1|]: p2 } = elems[0]; p2 < 100; p2++) {
+////interface I {
+////    [|property1|]: number;
+////    property2: string;
 ////}
-////for (let { [|property1|] } = elems[0]; p2 < 100; p2++) {
-////    [|property1|] = p2;
+////var elems: I[];
+////
+////var p2: number, property1: number;
+////for (let { [|property1|]: p2 } = elems[0]; p2 < 100; p2++) {
+////}
+////for (let { [|property1|] } = elems[0]; p2 < 100; p2++) {
+////    [|property1|] = p2;
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringDeclarationInForOf.ts b/tests/cases/fourslash/renameDestructuringDeclarationInForOf.ts
index 1c2b04b7ab5..fcd55a5bc20 100644
--- a/tests/cases/fourslash/renameDestructuringDeclarationInForOf.ts
+++ b/tests/cases/fourslash/renameDestructuringDeclarationInForOf.ts
@@ -1,19 +1,15 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    [|property1|]: number;
-////    property2: string;
-////}
-////var elems: I[];
-////
-////for (let { [|property1|] } of elems) {
-////    [|property1|]++;
+////interface I {
+////    [|property1|]: number;
+////    property2: string;
 ////}
-////for (let { [|property1|]: p2 } of elems) {
+////var elems: I[];
+////
+////for (let { [|property1|] } of elems) {
+////    [|property1|]++;
+////}
+////for (let { [|property1|]: p2 } of elems) {
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringFunctionParameter.ts b/tests/cases/fourslash/renameDestructuringFunctionParameter.ts
index d1df0f58275..4abbabc3723 100644
--- a/tests/cases/fourslash/renameDestructuringFunctionParameter.ts
+++ b/tests/cases/fourslash/renameDestructuringFunctionParameter.ts
@@ -1,10 +1,7 @@
 /// <reference path='fourslash.ts' />
 
-////function f({[|a|]}: {[|a|]}) {
-////    f({[|a|]});
+////function f({[|a|]}: {[|a|]}) {
+////    f({[|a|]});
 ////}
-let ranges = test.ranges();
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameDestructuringNestedBindingElement.ts b/tests/cases/fourslash/renameDestructuringNestedBindingElement.ts
index 1c4254b14ae..7557744ecee 100644
--- a/tests/cases/fourslash/renameDestructuringNestedBindingElement.ts
+++ b/tests/cases/fourslash/renameDestructuringNestedBindingElement.ts
@@ -1,5 +1,5 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface MultiRobot {
 ////    name: string;
 ////    skills: {
@@ -13,10 +13,6 @@
 ////}
 ////for (let { skills: {[|primary|], secondary } } of multiRobots) {
 ////    console.log([|primary|]);
-////}
-
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+////}
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameForDefaultExport01.ts b/tests/cases/fourslash/renameForDefaultExport01.ts
index 809c127a727..96f0d6e54e8 100644
--- a/tests/cases/fourslash/renameForDefaultExport01.ts
+++ b/tests/cases/fourslash/renameForDefaultExport01.ts
@@ -10,9 +10,4 @@
 ////
 ////var y = new /*3*/[|DefaultExportedClass|];
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-}
\ No newline at end of file
+goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameForDefaultExport02.ts b/tests/cases/fourslash/renameForDefaultExport02.ts
index ddf4b224023..471b10e32b2 100644
--- a/tests/cases/fourslash/renameForDefaultExport02.ts
+++ b/tests/cases/fourslash/renameForDefaultExport02.ts
@@ -11,9 +11,4 @@
 ////
 ////var y = /*4*/[|DefaultExportedFunction|]();
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-}
\ No newline at end of file
+goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameForDefaultExport03.ts b/tests/cases/fourslash/renameForDefaultExport03.ts
index 6f82d96fe5e..1da6ff20b0b 100644
--- a/tests/cases/fourslash/renameForDefaultExport03.ts
+++ b/tests/cases/fourslash/renameForDefaultExport03.ts
@@ -17,9 +17,4 @@
 ////    var local = 100;
 ////}
 
-let markers = test.markers()
-for (let marker of markers) {
-    goTo.position(marker.position);
-
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-}
\ No newline at end of file
+goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameImportAndExport.ts b/tests/cases/fourslash/renameImportAndExport.ts
index 495e15c1e7e..fe8bce4b208 100644
--- a/tests/cases/fourslash/renameImportAndExport.ts
+++ b/tests/cases/fourslash/renameImportAndExport.ts
@@ -3,8 +3,4 @@
 ////import [|a|] from "module";
 ////export { [|a|] };
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportAndShorthand.ts b/tests/cases/fourslash/renameImportAndShorthand.ts
index bc4746aebdd..4836d8c14fe 100644
--- a/tests/cases/fourslash/renameImportAndShorthand.ts
+++ b/tests/cases/fourslash/renameImportAndShorthand.ts
@@ -3,8 +3,4 @@
 ////import [|foo|] from 'bar';
 ////const bar = { [|foo|] };
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportNamespaceAndShorthand.ts b/tests/cases/fourslash/renameImportNamespaceAndShorthand.ts
index a6b06c11408..21cdc0fa820 100644
--- a/tests/cases/fourslash/renameImportNamespaceAndShorthand.ts
+++ b/tests/cases/fourslash/renameImportNamespaceAndShorthand.ts
@@ -3,8 +3,4 @@
 ////import * as [|foo|] from 'bar';
 ////const bar = { [|foo|] };
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportOfExportEquals.ts b/tests/cases/fourslash/renameImportOfExportEquals.ts
index 9d71ee907c8..192acefd6fd 100644
--- a/tests/cases/fourslash/renameImportOfExportEquals.ts
+++ b/tests/cases/fourslash/renameImportOfExportEquals.ts
@@ -11,8 +11,4 @@
 ////    export { [|N|] }; // Renaming N here would rename
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportRequire.ts b/tests/cases/fourslash/renameImportRequire.ts
index c26cc80b616..8a9aeebc328 100644
--- a/tests/cases/fourslash/renameImportRequire.ts
+++ b/tests/cases/fourslash/renameImportRequire.ts
@@ -1,12 +1,8 @@
 /// <reference path='fourslash.ts' />
 
-////import [|e|] = require("mod4");
-////[|e|];
-////a = { [|e|] };
+////import [|e|] = require("mod4");
+////[|e|];
+////a = { [|e|] };
 ////export { [|e|] };
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties1.ts b/tests/cases/fourslash/renameInheritedProperties1.ts
index 4698fe3d97b..b42335277a9 100644
--- a/tests/cases/fourslash/renameInheritedProperties1.ts
+++ b/tests/cases/fourslash/renameInheritedProperties1.ts
@@ -7,9 +7,4 @@
 //// var v: class1;
 //// v.[|propName|];
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties2.ts b/tests/cases/fourslash/renameInheritedProperties2.ts
index ed99ec3e013..bcc4c5fc323 100644
--- a/tests/cases/fourslash/renameInheritedProperties2.ts
+++ b/tests/cases/fourslash/renameInheritedProperties2.ts
@@ -7,9 +7,4 @@
 //// var v: class1;
 //// v.[|doStuff|]();
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties3.ts b/tests/cases/fourslash/renameInheritedProperties3.ts
index 17e7785fbc7..f1ec547d6ed 100644
--- a/tests/cases/fourslash/renameInheritedProperties3.ts
+++ b/tests/cases/fourslash/renameInheritedProperties3.ts
@@ -7,9 +7,4 @@
 //// var v: interface1;
 //// v.[|propName|];
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties4.ts b/tests/cases/fourslash/renameInheritedProperties4.ts
index ea2f7c40fbf..42d9acfdb53 100644
--- a/tests/cases/fourslash/renameInheritedProperties4.ts
+++ b/tests/cases/fourslash/renameInheritedProperties4.ts
@@ -7,9 +7,4 @@
 //// var v: interface1;
 //// v.[|doStuff|]();
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties5.ts b/tests/cases/fourslash/renameInheritedProperties5.ts
index 45058827747..e153742d4ed 100644
--- a/tests/cases/fourslash/renameInheritedProperties5.ts
+++ b/tests/cases/fourslash/renameInheritedProperties5.ts
@@ -9,9 +9,5 @@
 //// var d: D;
 //// d.[|propD|];
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
+
diff --git a/tests/cases/fourslash/renameInheritedProperties6.ts b/tests/cases/fourslash/renameInheritedProperties6.ts
index 6bdd32ce3e0..59318334cb0 100644
--- a/tests/cases/fourslash/renameInheritedProperties6.ts
+++ b/tests/cases/fourslash/renameInheritedProperties6.ts
@@ -9,9 +9,4 @@
 //// var d: D;
 //// d.[|propC|];
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties7.ts b/tests/cases/fourslash/renameInheritedProperties7.ts
index a2f8c5a2b51..bc0521458f8 100644
--- a/tests/cases/fourslash/renameInheritedProperties7.ts
+++ b/tests/cases/fourslash/renameInheritedProperties7.ts
@@ -3,17 +3,12 @@
 //// class C extends D {
 ////     [|prop1|]: string;
 //// }
-//// 
+////
 //// class D extends C {
 ////     prop1: string;
 //// }
-//// 
+////
 //// var c: C;
 //// c.[|prop1|];
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameInheritedProperties8.ts b/tests/cases/fourslash/renameInheritedProperties8.ts
index 119e1a477aa..7cde300bf0b 100644
--- a/tests/cases/fourslash/renameInheritedProperties8.ts
+++ b/tests/cases/fourslash/renameInheritedProperties8.ts
@@ -3,17 +3,12 @@
 //// class C implements D {
 ////     [|prop1|]: string;
 //// }
-//// 
+////
 //// interface D extends C {
 ////     [|prop1|]: string;
 //// }
-//// 
+////
 //// var c: C;
 //// c.[|prop1|];
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameLocationsForClassExpression01.ts b/tests/cases/fourslash/renameLocationsForClassExpression01.ts
index b95040085c9..b0f2f509500 100644
--- a/tests/cases/fourslash/renameLocationsForClassExpression01.ts
+++ b/tests/cases/fourslash/renameLocationsForClassExpression01.ts
@@ -11,7 +11,7 @@
 ////    static doItStatically() {
 ////        return [|Foo|].y;
 ////    }
-////} 
+////}
 ////
 ////var y = class {
 ////   getSomeName() {
@@ -20,8 +20,4 @@
 ////}
 ////var z = class Foo {}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts
index e884783d960..1e02e3f5284 100644
--- a/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts
+++ b/tests/cases/fourslash/renameLocationsForFunctionExpression01.ts
@@ -4,9 +4,4 @@
 ////    [|f|]([|f|], g);
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts b/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts
index 8186611cb64..a258bcd803d 100644
--- a/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts
+++ b/tests/cases/fourslash/renameLocationsForFunctionExpression02.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts'/>
 
 ////function f() {
-////    
+////
 ////}
 ////var x = function [|f|](g: any, h: any) {
 ////
@@ -10,9 +10,4 @@
 ////    let foo = () => [|f|]([|f|], g);
 ////}
 
-let ranges = test.ranges()
-for (let range of ranges) {
-    goTo.position(range.start);
-
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameObjectBindingElementPropertyName01.ts b/tests/cases/fourslash/renameObjectBindingElementPropertyName01.ts
index 535dbd3d5a3..4ae87f19db5 100644
--- a/tests/cases/fourslash/renameObjectBindingElementPropertyName01.ts
+++ b/tests/cases/fourslash/renameObjectBindingElementPropertyName01.ts
@@ -8,7 +8,4 @@
 ////var foo: I;
 ////var { [|property1|]: prop1 } = foo;
 
-for (let range of test.ranges()) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameObjectSpread.ts b/tests/cases/fourslash/renameObjectSpread.ts
index eba148c0e39..f56c22dd42f 100644
--- a/tests/cases/fourslash/renameObjectSpread.ts
+++ b/tests/cases/fourslash/renameObjectSpread.ts
@@ -10,11 +10,11 @@ const ranges = test.ranges();
 verify.assertHasRanges(ranges);
 
 // A1 unions with A2, so rename A1.a and a12.a
-goTo.position(ranges[0].start);
+goTo.rangeStart(ranges[0]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
 // A1 unions with A2, so rename A2.a and a12.a
-goTo.position(ranges[1].start);
+goTo.rangeStart(ranges[1]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[2]]);
 // a12.a unions A1.a and A2.a, so rename A1.a, A2.a and a12.a
-goTo.position(ranges[2].start);
+goTo.rangeStart(ranges[2]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[1], ranges[2]]);
diff --git a/tests/cases/fourslash/renameObjectSpreadAssignment.ts b/tests/cases/fourslash/renameObjectSpreadAssignment.ts
index 9cf0b6ebf81..2ddebb6e18b 100644
--- a/tests/cases/fourslash/renameObjectSpreadAssignment.ts
+++ b/tests/cases/fourslash/renameObjectSpreadAssignment.ts
@@ -5,16 +5,18 @@
 ////let [|a1|]: A1;
 ////let [|a2|]: A2;
 ////let a12 = { ...[|a1|], ...[|a2|] };
+
 const ranges = test.ranges();
 verify.assertHasRanges(ranges);
 
+
 // rename a1
-goTo.position(ranges[0].start);
+goTo.rangeStart(ranges[0]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
-goTo.position(ranges[2].start);
+goTo.rangeStart(ranges[2]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
 // rename a2
-goTo.position(ranges[1].start);
+goTo.rangeStart(ranges[1]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]);
-goTo.position(ranges[3].start);
+goTo.rangeStart(ranges[3]);
 verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]);
diff --git a/tests/cases/fourslash/renameParameterPropertyDeclaration1.ts b/tests/cases/fourslash/renameParameterPropertyDeclaration1.ts
index 42bfbf63a47..14f8a240bfb 100644
--- a/tests/cases/fourslash/renameParameterPropertyDeclaration1.ts
+++ b/tests/cases/fourslash/renameParameterPropertyDeclaration1.ts
@@ -7,9 +7,4 @@
 ////     }
 //// }
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameParameterPropertyDeclaration2.ts b/tests/cases/fourslash/renameParameterPropertyDeclaration2.ts
index e7ef9d1c1a2..ce31ad6c9c5 100644
--- a/tests/cases/fourslash/renameParameterPropertyDeclaration2.ts
+++ b/tests/cases/fourslash/renameParameterPropertyDeclaration2.ts
@@ -7,9 +7,4 @@
 ////     }
 //// }
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameParameterPropertyDeclaration3.ts b/tests/cases/fourslash/renameParameterPropertyDeclaration3.ts
index 9446e2aeb75..6291eff2605 100644
--- a/tests/cases/fourslash/renameParameterPropertyDeclaration3.ts
+++ b/tests/cases/fourslash/renameParameterPropertyDeclaration3.ts
@@ -7,9 +7,4 @@
 ////     }
 //// }
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameParameterPropertyDeclaration4.ts b/tests/cases/fourslash/renameParameterPropertyDeclaration4.ts
index 7fb4b8c757d..ca201d28b2c 100644
--- a/tests/cases/fourslash/renameParameterPropertyDeclaration4.ts
+++ b/tests/cases/fourslash/renameParameterPropertyDeclaration4.ts
@@ -6,9 +6,4 @@
 ////     }
 //// }
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameParameterPropertyDeclaration5.ts b/tests/cases/fourslash/renameParameterPropertyDeclaration5.ts
index b7c47a4c0d7..f989e7c3fd9 100644
--- a/tests/cases/fourslash/renameParameterPropertyDeclaration5.ts
+++ b/tests/cases/fourslash/renameParameterPropertyDeclaration5.ts
@@ -6,9 +6,4 @@
 ////     }
 //// }
 
-let ranges = test.ranges();
-verify.assertHasRanges(ranges);
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameRest.ts b/tests/cases/fourslash/renameRest.ts
index a5cc2c38683..60fc1bbb227 100644
--- a/tests/cases/fourslash/renameRest.ts
+++ b/tests/cases/fourslash/renameRest.ts
@@ -7,9 +7,5 @@
 ////let t: Gen;
 ////var { x, ...rest } = t;
 ////rest.[|parent|];
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-goTo.position(ranges[0].start);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, ranges);
-goTo.position(ranges[1].start);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, ranges);
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameStingPropertyNames.ts b/tests/cases/fourslash/renameStingPropertyNames.ts
index a948220efad..13863b043e7 100644
--- a/tests/cases/fourslash/renameStingPropertyNames.ts
+++ b/tests/cases/fourslash/renameStingPropertyNames.ts
@@ -12,9 +12,4 @@
 ////o['[|prop|]'];
 ////o.[|prop|];
 
-
-let ranges = test.ranges();
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameStringLiteralTypes.ts b/tests/cases/fourslash/renameStringLiteralTypes.ts
index f9df83371c1..d0e7368f25d 100644
--- a/tests/cases/fourslash/renameStringLiteralTypes.ts
+++ b/tests/cases/fourslash/renameStringLiteralTypes.ts
@@ -11,8 +11,4 @@
 ////
 ////animate({ deltaX: 100, deltaY: 100, easing: "[|ease-in-out|]" });
 
-let ranges = test.ranges();
-for (let range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameThis.ts b/tests/cases/fourslash/renameThis.ts
index f567cace70d..c4e5d932261 100644
--- a/tests/cases/fourslash/renameThis.ts
+++ b/tests/cases/fourslash/renameThis.ts
@@ -8,7 +8,7 @@
 
 let [r0, r1, r2, r3] = test.ranges()
 for (let range of [r0, r1]) {
-    goTo.position(range.start);
+    goTo.rangeStart(range);
     verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r0, r1]);
 }
 
@@ -17,6 +17,6 @@ goTo.marker();
 verify.renameInfoFailed("You cannot rename this element.");
 
 for (let range of [r2, r3]) {
-    goTo.position(range.start);
+    goTo.rangeStart(range);
     verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r2, r3]);
 }
diff --git a/tests/cases/fourslash/renameUMDModuleAlias1.ts b/tests/cases/fourslash/renameUMDModuleAlias1.ts
index 94aabcdbde5..c44e459b008 100644
--- a/tests/cases/fourslash/renameUMDModuleAlias1.ts
+++ b/tests/cases/fourslash/renameUMDModuleAlias1.ts
@@ -10,8 +10,4 @@
 //// /// <reference path="0.d.ts" />
 //// [|myLib|].doThing();
 
-const ranges = test.ranges()
-for (const range of ranges) {
-    goTo.position(range.start);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-}
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/server/occurrences01.ts b/tests/cases/fourslash/server/occurrences01.ts
index db2fa64f38d..f6e39d55b91 100644
--- a/tests/cases/fourslash/server/occurrences01.ts
+++ b/tests/cases/fourslash/server/occurrences01.ts
@@ -10,13 +10,4 @@
 ////        continue foo;
 ////}
 
-let ranges = test.ranges();
-
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(ranges.length);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range, /*isWriteAccess*/ false);
-    }
-}
\ No newline at end of file
+verify.rangesAreOccurrences(false);
diff --git a/tests/cases/fourslash/server/occurrences02.ts b/tests/cases/fourslash/server/occurrences02.ts
index e0d39cb92fd..4cf8f1bcac3 100644
--- a/tests/cases/fourslash/server/occurrences02.ts
+++ b/tests/cases/fourslash/server/occurrences02.ts
@@ -4,13 +4,4 @@
 ////    [|f|]([|f|]);
 ////}
 
-let ranges = test.ranges();
-
-for (let r of ranges) {
-    goTo.position(r.start);
-    verify.occurrencesAtPositionCount(ranges.length);
-
-    for (let range of ranges) {
-        verify.occurrencesAtPositionContains(range);
-    }
-}
\ No newline at end of file
+verify.rangesAreOccurrences();
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates1.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates1.ts
index 39644ba8c24..87c9262f893 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates1.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates1.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/ qwe/*2*/rty /*3*/$/*4*/{ 123 }/*5*/ as/*6*/df /*7*/$/*8*/{   41234   }/*9*/  zxc/*10*/vb /*11*/$/*12*/{ g `    ` }/*13*/  /*14*/  /*15*/`
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates2.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates2.ts
index 123a6cc4c2c..ef306a22934 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates2.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates2.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/ qwe/*2*/rty /*3*/$/*4*/{ 123 }/*5*/ as/*6*/df /*7*/$/*8*/{   41234   }/*9*/  zxc/*10*/vb /*11*/$/*12*/{ g `    ` }/*13*/  /*14*/  /*15*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates3.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates3.ts
index f203468ca04..7859fd6f457 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates3.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates3.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f ` qwerty ${/*1*/ /*2*/123/*3*/ /*4*/} asdf ${   41234   }  zxcvb ${ g `    ` }    `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates4.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates4.ts
index 13ee47a3309..4c8ce2cd917 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates4.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates4.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f ` qwerty ${ 123 } asdf ${/*1*/  /*2*/ /*3*/41/*4*/234/*5*/   /*6*/}  zxcvb ${ g `    ` }    `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates5.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates5.ts
index 7cd2affd675..03ef244e719 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates5.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates5.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f ` qwerty ${ 123 } asdf ${   41234   }  zxcvb ${/*1*/ /*2*/g/*3*/ /*4*/`    `/*5*/ /*6*/}    `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates6.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates6.ts
index 7671666bb54..67ab1199be8 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates6.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates6.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f ` qwerty ${ 123 } asdf ${   41234   }  zxcvb ${ g `/*1*/ /*2*/   /*3*/` }    `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(1);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplates7.ts b/tests/cases/fourslash/signatureHelpTaggedTemplates7.ts
index 35bed336f39..cd17ddd1027 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplates7.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplates7.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/    /*2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(1);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete1.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete1.ts
index 1da96ea5c1b..2995c6cdcd8 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete1.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete1.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
-//// f `/*1*/   /*2*/${      
-
-test.markers().forEach(m => {
-    goTo.position(m.position);
+////
+//// f `/*1*/   /*2*/${
 
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(2);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete2.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete2.ts
index 68ff7202f01..d1ceebfb1b0 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete2.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete2.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${/*1*/      /*2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(2);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete3.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete3.ts
index 8165da7f67b..211fa66f594 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete3.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete3.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${      }/*1*/ /*2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(2);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete4.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete4.ts
index 8c970b60c77..79432077ce9 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete4.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete4.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${      } ${/*1*/  /*2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete5.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete5.ts
index f93da36ce5c..18ffdbe3bf0 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete5.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete5.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${      } ${  }/*1*/   /*2*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete6.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete6.ts
index 10d81eb80f4..fdd6f22554d 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete6.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete6.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${  123 } ${/*1*/  }   `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete7.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete7.ts
index a8afe2d9c6d..9bc4a535564 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete7.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete7.ts
@@ -2,15 +2,13 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `   ${  123 } /*1*/${  }   /*2*/\/*3*/
 //// /*4*/\\/*5*/
 //// /*6*/\\\/*7*/
 //// /*8*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete8.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete8.ts
index 86455a65ccd..05ab05c3e6c 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete8.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete8.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/\/*2*/`/*3*/ /*4*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(1);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete9.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete9.ts
index de42a33b397..597ec928bb9 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete9.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesIncomplete9.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/  \\\/*2*/`/*3*/ /*4*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
     verify.signatureHelpArgumentCountIs(1);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives1.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives1.ts
index c61f1a871e4..10f9f81fa61 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives1.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives1.ts
@@ -2,10 +2,7 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// /*1*/f/*2*/ /*3*/` qwerty ${ 123 } asdf ${   41234   }  zxcvb ${ g `    ` }     `/*4*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.not.signatureHelpPresent();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.not.signatureHelpPresent());
\ No newline at end of file
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives2.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives2.ts
index e7a5078dcd0..da21fda631c 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives2.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives2.ts
@@ -2,10 +2,7 @@
 
 //// function foo(strs, ...rest) {
 //// }
-//// 
+////
 //// /*1*/fo/*2*/o /*3*/`abcd${0 + 1}abcd{1 + 1}`/*4*/  /*5*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.not.signatureHelpPresent();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.not.signatureHelpPresent());
\ No newline at end of file
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives3.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives3.ts
index c84b92fee4f..9ccbe927a57 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives3.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives3.ts
@@ -2,10 +2,7 @@
 
 //// function foo(strs, ...rest) {
 //// }
-//// 
+////
 //// /*1*/fo/*2*/o /*3*/`abcd${0 + 1}abcd{1 + 1}abcd`/*4*/  /*5*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.not.signatureHelpPresent();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.not.signatureHelpPresent());
\ No newline at end of file
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives4.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives4.ts
index 338a8dc65ca..825afd265ab 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives4.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives4.ts
@@ -2,10 +2,7 @@
 
 //// function foo(strs, ...rest) {
 //// }
-//// 
+////
 //// /*1*/fo/*2*/o /*3*/``/*4*/  /*5*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.not.signatureHelpPresent();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.not.signatureHelpPresent());
\ No newline at end of file
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives5.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives5.ts
index 02383df9267..5b14b627f6a 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives5.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNegatives5.ts
@@ -2,10 +2,7 @@
 
 //// function foo(strs, ...rest) {
 //// }
-//// 
+////
 //// /*1*/fo/*2*/o /*3*/`abcd`/*4*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-    verify.not.signatureHelpPresent();
-});
\ No newline at end of file
+goTo.eachMarker(() => verify.not.signatureHelpPresent());
\ No newline at end of file
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNested1.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNested1.ts
index a3c9f7ccce4..313e55bf517 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNested1.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNested1.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `a ${ g `/*1*/alpha/*2*/ ${/*3*/ 12/*4*/3 /*5*/} beta /*6*/${ /*7*/456 /*8*/} gamma/*9*/` } b ${ g `/*10*/txt/*11*/` } c ${ g `/*12*/aleph /*13*/$/*14*/{ 12/*15*/3 } beit/*16*/` } d`;
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
 
     verify.currentSignatureParameterCountIs(4);
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesNested2.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesNested2.ts
index d72fa74d985..aa04e425998 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesNested2.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesNested2.ts
@@ -2,12 +2,10 @@
 
 //// function f(templateStrings, x, y, z) { return 10; }
 //// function g(templateStrings, x, y, z) { return ""; }
-//// 
+////
 //// f `/*1*/a $/*2*/{ /*3*/g /*4*/`alpha ${ 123 } beta ${ 456 } gamma`/*5*/ }/*6*/ b $/*7*/{ /*8*/g /*9*/`txt`/*10*/ } /*11*/c ${ /*12*/g /*13*/`aleph ${ 123 } beit`/*14*/ } d/*15*/`;
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(1);
 
     verify.currentSignatureParameterCountIs(4);
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags1.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags1.ts
index 6850b1bc54f..54aee5887b8 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags1.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags1.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `/*1*/  /*2*/$/*3*/{
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(2);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags2.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags2.ts
index 8466c6b05f2..9cbd20a49d2 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags2.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags2.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${/*1*/ /*2*/ /*3*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(2);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts
index b919afc7703..a9b91dbf438 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: TemplateStringsArray, p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${/*1*/ "s/*2*/tring" /*3*/ }   ${
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags4.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags4.ts
index a1072366a98..96ff7c4683a 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags4.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags4.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${/*1*/ 123.456/*2*/ /*3*/ }   ${
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags5.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags5.ts
index 2646e70b39c..52a1e3f74be 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags5.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags5.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${ }   ${/*1*/ /*2*/ /*3*/
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags6.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags6.ts
index 62410a5fda3..b34df14e926 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags6.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags6.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${ }   ${/*1*/ /*2*/ /*3*/}
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts
index 5f706b8c0fa..26a80e36f6f 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: TemplateStringsArray, p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${ }   ${/*1*/ fa/*2*/lse /*3*/}
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags8.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags8.ts
index 8000f15d3c6..6b9daa60dcc 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags8.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags8.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
+////
 //// f `${ undefined }   ${ undefined }    ${/*1*/   10/*2*/./*3*/01 /*4*/} `
 
-test.markers().forEach(m => {
-    goTo.position(m.position);
-
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(4);
 
diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags9.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags9.ts
index aee06c1df53..cbcc55a2f22 100644
--- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags9.ts
+++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags9.ts
@@ -4,12 +4,10 @@
 //// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string;
 //// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean;
 //// function f(...foo[]: any) { return ""; }
-//// 
-//// f `${/*1*/ /*2*/ /*3*/}   ${ 
-
-test.markers().forEach(m => {
-    goTo.position(m.position);
+////
+//// f `${/*1*/ /*2*/ /*3*/}   ${
 
+goTo.eachMarker(() => {
     verify.signatureHelpCountIs(3);
     verify.signatureHelpArgumentCountIs(3);
 
diff --git a/tests/cases/fourslash_old/completionListGenericConstraintsNames.ts b/tests/cases/fourslash_old/completionListGenericConstraintsNames.ts
index 3e60456f389..92d288dcb2a 100644
--- a/tests/cases/fourslash_old/completionListGenericConstraintsNames.ts
+++ b/tests/cases/fourslash_old/completionListGenericConstraintsNames.ts
@@ -17,9 +17,8 @@
 ////    }
 ////}
 
- test.markers().forEach((marker) => {
-     goTo.position(marker.position, marker.fileName);
-     verify.memberListContains("T");
-     verify.memberListContains("U");
-     verify.memberListContains("M");
+goTo.eachMarker(() => {
+    verify.memberListContains("T");
+    verify.memberListContains("U");
+    verify.memberListContains("M");
  });

From a6c5306479d1ca150657967f77fa2a195db4b793 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 19 Jan 2017 13:58:09 -0800
Subject: [PATCH 068/159] Allow object intersection types as class/interface
 base types

---
 src/compiler/checker.ts  | 53 ++++++++++++++++++++++++++--------------
 src/compiler/types.ts    |  7 ++++--
 src/services/services.ts |  2 +-
 src/services/types.ts    |  2 +-
 4 files changed, 42 insertions(+), 22 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 756a2b2d3b1..9cc5fb111cd 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3732,11 +3732,16 @@ namespace ts {
             return getObjectFlags(type) & ObjectFlags.Reference ? (<TypeReference>type).target : type;
         }
 
-        function hasBaseType(type: InterfaceType, checkBase: InterfaceType) {
+        function hasBaseType(type: BaseType, checkBase: BaseType) {
             return check(type);
-            function check(type: InterfaceType): boolean {
-                const target = <InterfaceType>getTargetType(type);
-                return target === checkBase || forEach(getBaseTypes(target), check);
+            function check(type: BaseType): boolean {
+                if (getObjectFlags(type) & (ObjectFlags.ClassOrInterface | ObjectFlags.Reference)) {
+                    const target = <InterfaceType>getTargetType(type);
+                    return target === checkBase || forEach(getBaseTypes(target), check);
+                }
+                else if (type.flags & TypeFlags.Intersection) {
+                    return forEach((<IntersectionType>type).types, check);
+                }
             }
         }
 
@@ -3862,7 +3867,7 @@ namespace ts {
             return type.resolvedBaseConstructorType;
         }
 
-        function getBaseTypes(type: InterfaceType): ObjectType[] {
+        function getBaseTypes(type: InterfaceType): BaseType[] {
             if (!type.resolvedBaseTypes) {
                 if (type.objectFlags & ObjectFlags.Tuple) {
                     type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
@@ -3922,11 +3927,11 @@ namespace ts {
             if (baseType === unknownType) {
                 return;
             }
-            if (!(getObjectFlags(getTargetType(baseType)) & ObjectFlags.ClassOrInterface)) {
+            if (!isValidBaseType(baseType)) {
                 error(baseTypeNode.expression, Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType));
                 return;
             }
-            if (type === baseType || hasBaseType(<InterfaceType>baseType, type)) {
+            if (type === baseType || hasBaseType(<BaseType>baseType, type)) {
                 error(valueDecl, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
                     typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
                 return;
@@ -3951,6 +3956,13 @@ namespace ts {
             return true;
         }
 
+        // A valid base type is any non-generic object type or intersection of non-generic
+        // object types.
+        function isValidBaseType(type: Type): boolean {
+            return type.flags & TypeFlags.Object && !isGenericMappedType(type) ||
+                type.flags & TypeFlags.Intersection && !forEach((<IntersectionType>type).types, t => !isValidBaseType(t));
+        }
+
         function resolveBaseTypesOfInterface(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
             for (const declaration of type.symbol.declarations) {
@@ -3958,8 +3970,8 @@ namespace ts {
                     for (const node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
                         const baseType = getTypeFromTypeNode(node);
                         if (baseType !== unknownType) {
-                            if (getObjectFlags(getTargetType(baseType)) & ObjectFlags.ClassOrInterface) {
-                                if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
+                            if (isValidBaseType(baseType)) {
+                                if (type !== baseType && !hasBaseType(<BaseType>baseType, type)) {
                                     if (type.resolvedBaseTypes === emptyArray) {
                                         type.resolvedBaseTypes = [<ObjectType>baseType];
                                     }
@@ -4317,6 +4329,9 @@ namespace ts {
                 return createTypeReference((<TypeReference>type).target,
                     concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
             }
+            if (type.flags & TypeFlags.Intersection) {
+                return getIntersectionType(map((<IntersectionType>type).types, t => getTypeWithThisArgument(t, thisArgument)));
+            }
             return type;
         }
 
@@ -4350,8 +4365,8 @@ namespace ts {
                 }
                 const thisArgument = lastOrUndefined(typeArguments);
                 for (const baseType of baseTypes) {
-                    const instantiatedBaseType = thisArgument ? getTypeWithThisArgument(<ObjectType>instantiateType(baseType, mapper), thisArgument) : baseType;
-                    addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
+                    const instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
+                    addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType));
                     callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call));
                     constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct));
                     stringIndexInfo = stringIndexInfo || getIndexInfoOfType(instantiatedBaseType, IndexKind.String);
@@ -18216,16 +18231,18 @@ namespace ts {
                     return;
                 }
 
+                const propDeclaration = prop.valueDeclaration;
+
                 // index is numeric and property name is not valid numeric literal
-                if (indexKind === IndexKind.Number && !isNumericName(prop.valueDeclaration.name)) {
+                if (indexKind === IndexKind.Number && propDeclaration && !isNumericName(propDeclaration.name)) {
                     return;
                 }
 
                 // perform property check if property or indexer is declared in 'type'
                 // this allows to rule out cases when both property and indexer are inherited from the base class
                 let errorNode: Node;
-                if (prop.valueDeclaration.name.kind === SyntaxKind.ComputedPropertyName || prop.parent === containingType.symbol) {
-                    errorNode = prop.valueDeclaration;
+                if (propDeclaration && propDeclaration.name.kind === SyntaxKind.ComputedPropertyName || prop.parent === containingType.symbol) {
+                    errorNode = propDeclaration;
                 }
                 else if (indexDeclaration) {
                     errorNode = indexDeclaration;
@@ -18364,7 +18381,7 @@ namespace ts {
                     checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node,
                         Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
 
-                    if (baseType.symbol.valueDeclaration &&
+                    if (baseType.symbol && baseType.symbol.valueDeclaration &&
                         !isInAmbientContext(baseType.symbol.valueDeclaration) &&
                         baseType.symbol.valueDeclaration.kind === SyntaxKind.ClassDeclaration) {
                         if (!isBlockScopedNameDeclaredBeforeUse(baseType.symbol.valueDeclaration, node)) {
@@ -18437,7 +18454,7 @@ namespace ts {
             return forEach(symbol.declarations, d => isClassLike(d) ? d : undefined);
         }
 
-        function checkKindsOfPropertyMemberOverrides(type: InterfaceType, baseType: ObjectType): void {
+        function checkKindsOfPropertyMemberOverrides(type: InterfaceType, baseType: BaseType): void {
 
             // TypeScript 1.0 spec (April 2014): 8.2.3
             // A derived class inherits all members from its base class it doesn't override.
@@ -18454,7 +18471,7 @@ namespace ts {
             // derived class instance member variables and accessors, but not by other kinds of members.
 
             // NOTE: assignability is checked in checkClassDeclaration
-            const baseProperties = getPropertiesOfObjectType(baseType);
+            const baseProperties = getPropertiesOfType(baseType);
             for (const baseProperty of baseProperties) {
                 const base = getTargetSymbol(baseProperty);
 
@@ -18578,7 +18595,7 @@ namespace ts {
             let ok = true;
 
             for (const base of baseTypes) {
-                const properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
+                const properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
                 for (const prop of properties) {
                     const existing = seen.get(prop.name);
                     if (!existing) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 51347c8d3df..b834d73300a 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2358,7 +2358,7 @@
         getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo;
         getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
-        getBaseTypes(type: InterfaceType): ObjectType[];
+        getBaseTypes(type: InterfaceType): BaseType[];
         getReturnTypeOfSignature(signature: Signature): Type;
         /**
          * Gets the type of a parameter at a given position in a signature.
@@ -2910,9 +2910,12 @@
         /* @internal */
         resolvedBaseConstructorType?: Type;        // Resolved base constructor type of class
         /* @internal */
-        resolvedBaseTypes: ObjectType[];           // Resolved base types
+        resolvedBaseTypes: BaseType[];             // Resolved base types
     }
 
+    // Object type or intersection of object types
+    export type BaseType = ObjectType | IntersectionType;
+
     export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
         declaredProperties: Symbol[];              // Declared members
         declaredCallSignatures: Signature[];       // Declared call signatures
diff --git a/src/services/services.ts b/src/services/services.ts
index 26374eccbfd..04cb233557f 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -379,7 +379,7 @@ namespace ts {
         getNumberIndexType(): Type {
             return this.checker.getIndexTypeOfType(this, IndexKind.Number);
         }
-        getBaseTypes(): ObjectType[] {
+        getBaseTypes(): BaseType[] {
             return this.flags & TypeFlags.Object && this.objectFlags & (ObjectFlags.Class | ObjectFlags.Interface)
                 ? this.checker.getBaseTypes(<InterfaceType><Type>this)
                 : undefined;
diff --git a/src/services/types.ts b/src/services/types.ts
index 88ffe2950ce..f410eb5b401 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -33,7 +33,7 @@ namespace ts {
         getConstructSignatures(): Signature[];
         getStringIndexType(): Type;
         getNumberIndexType(): Type;
-        getBaseTypes(): ObjectType[];
+        getBaseTypes(): BaseType[];
         getNonNullableType(): Type;
     }
 

From d22b963b0bd4984597e003ca4267e1dca6f44183 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Thu, 19 Jan 2017 13:51:34 -0800
Subject: [PATCH 069/159] Add test for decorator referencing alias named Event

---
 .../reference/metadataOfEventAlias.js         | 38 +++++++++++++++++++
 .../reference/metadataOfEventAlias.symbols    | 23 +++++++++++
 .../reference/metadataOfEventAlias.types      | 23 +++++++++++
 tests/cases/compiler/metadataOfEventAlias.ts  | 14 +++++++
 4 files changed, 98 insertions(+)
 create mode 100644 tests/baselines/reference/metadataOfEventAlias.js
 create mode 100644 tests/baselines/reference/metadataOfEventAlias.symbols
 create mode 100644 tests/baselines/reference/metadataOfEventAlias.types
 create mode 100644 tests/cases/compiler/metadataOfEventAlias.ts

diff --git a/tests/baselines/reference/metadataOfEventAlias.js b/tests/baselines/reference/metadataOfEventAlias.js
new file mode 100644
index 00000000000..a79a2daa5d9
--- /dev/null
+++ b/tests/baselines/reference/metadataOfEventAlias.js
@@ -0,0 +1,38 @@
+//// [tests/cases/compiler/metadataOfEventAlias.ts] ////
+
+//// [event.ts]
+
+export interface Event { title: string };
+
+//// [test.ts]
+import { Event } from './event';
+function Input(target: any, key: string): void { }
+export class SomeClass {
+    @Input event: Event;
+}
+
+//// [event.js]
+"use strict";
+;
+//// [test.js]
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+function Input(target, key) { }
+var SomeClass = (function () {
+    function SomeClass() {
+    }
+    return SomeClass;
+}());
+__decorate([
+    Input,
+    __metadata("design:type", event_1.Event)
+], SomeClass.prototype, "event", void 0);
+exports.SomeClass = SomeClass;
diff --git a/tests/baselines/reference/metadataOfEventAlias.symbols b/tests/baselines/reference/metadataOfEventAlias.symbols
new file mode 100644
index 00000000000..441714e63e6
--- /dev/null
+++ b/tests/baselines/reference/metadataOfEventAlias.symbols
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/event.ts ===
+
+export interface Event { title: string };
+>Event : Symbol(Event, Decl(event.ts, 0, 0))
+>title : Symbol(Event.title, Decl(event.ts, 1, 24))
+
+=== tests/cases/compiler/test.ts ===
+import { Event } from './event';
+>Event : Symbol(Event, Decl(test.ts, 0, 8))
+
+function Input(target: any, key: string): void { }
+>Input : Symbol(Input, Decl(test.ts, 0, 32))
+>target : Symbol(target, Decl(test.ts, 1, 15))
+>key : Symbol(key, Decl(test.ts, 1, 27))
+
+export class SomeClass {
+>SomeClass : Symbol(SomeClass, Decl(test.ts, 1, 50))
+
+    @Input event: Event;
+>Input : Symbol(Input, Decl(test.ts, 0, 32))
+>event : Symbol(SomeClass.event, Decl(test.ts, 2, 24))
+>Event : Symbol(Event, Decl(test.ts, 0, 8))
+}
diff --git a/tests/baselines/reference/metadataOfEventAlias.types b/tests/baselines/reference/metadataOfEventAlias.types
new file mode 100644
index 00000000000..b644552f9c2
--- /dev/null
+++ b/tests/baselines/reference/metadataOfEventAlias.types
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/event.ts ===
+
+export interface Event { title: string };
+>Event : Event
+>title : string
+
+=== tests/cases/compiler/test.ts ===
+import { Event } from './event';
+>Event : any
+
+function Input(target: any, key: string): void { }
+>Input : (target: any, key: string) => void
+>target : any
+>key : string
+
+export class SomeClass {
+>SomeClass : SomeClass
+
+    @Input event: Event;
+>Input : (target: any, key: string) => void
+>event : Event
+>Event : Event
+}
diff --git a/tests/cases/compiler/metadataOfEventAlias.ts b/tests/cases/compiler/metadataOfEventAlias.ts
new file mode 100644
index 00000000000..c62e1480c89
--- /dev/null
+++ b/tests/cases/compiler/metadataOfEventAlias.ts
@@ -0,0 +1,14 @@
+// @experimentalDecorators: true
+// @emitDecoratorMetadata: true
+// @target: es5
+// @includeBuiltFile: lib.d.ts
+
+// @filename: event.ts
+export interface Event { title: string };
+
+// @filename: test.ts
+import { Event } from './event';
+function Input(target: any, key: string): void { }
+export class SomeClass {
+    @Input event: Event;
+}
\ No newline at end of file

From 679a7ec04f544d05104cc11ba3e6f99da6ac98b2 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Thu, 19 Jan 2017 14:27:53 -0800
Subject: [PATCH 070/159] Use the value symbol for decorator purpose only if it
 is same as typesymbol Fixes #13155

---
 src/compiler/checker.ts                       | 21 +++++++++++--------
 .../reference/metadataOfEventAlias.js         |  2 +-
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 756a2b2d3b1..ad0a8dbaebb 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -20518,18 +20518,21 @@ namespace ts {
         function getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind {
             // Resolve the symbol as a value to ensure the type can be reached at runtime during emit.
             const valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location);
-            const globalPromiseSymbol = tryGetGlobalPromiseConstructorSymbol();
-            if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) {
-                return TypeReferenceSerializationKind.Promise;
-            }
-
-            const constructorType = valueSymbol ? getTypeOfSymbol(valueSymbol) : undefined;
-            if (constructorType && isConstructorType(constructorType)) {
-                return TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
-            }
 
             // Resolve the symbol as a type so that we can provide a more useful hint for the type serializer.
             const typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location);
+            if (valueSymbol && valueSymbol === typeSymbol) {
+                const globalPromiseSymbol = tryGetGlobalPromiseConstructorSymbol();
+                if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) {
+                    return TypeReferenceSerializationKind.Promise;
+                }
+
+                const constructorType = getTypeOfSymbol(valueSymbol);
+                if (constructorType && isConstructorType(constructorType)) {
+                    return TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
+                }
+            }
+
             // We might not be able to resolve type symbol so use unknown type in that case (eg error case)
             if (!typeSymbol) {
                 return TypeReferenceSerializationKind.ObjectType;
diff --git a/tests/baselines/reference/metadataOfEventAlias.js b/tests/baselines/reference/metadataOfEventAlias.js
index a79a2daa5d9..8a22a90bc2e 100644
--- a/tests/baselines/reference/metadataOfEventAlias.js
+++ b/tests/baselines/reference/metadataOfEventAlias.js
@@ -33,6 +33,6 @@ var SomeClass = (function () {
 }());
 __decorate([
     Input,
-    __metadata("design:type", event_1.Event)
+    __metadata("design:type", Object)
 ], SomeClass.prototype, "event", void 0);
 exports.SomeClass = SomeClass;

From 1c2f7f866bd19d8ebbf3a4fe35b096bf512efba2 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 19 Jan 2017 14:30:53 -0800
Subject: [PATCH 071/159] Improve efficiency of union/intersection resolved
 property caching

---
 src/compiler/checker.ts | 40 +++++++++++++++++++---------------------
 src/compiler/types.ts   |  4 +++-
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9cc5fb111cd..1ca1cd9cf74 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4754,28 +4754,26 @@ namespace ts {
         }
 
         function getPropertiesOfUnionOrIntersectionType(type: UnionOrIntersectionType): Symbol[] {
-            for (const current of type.types) {
-                for (const prop of getPropertiesOfType(current)) {
-                    getUnionOrIntersectionProperty(type, prop.name);
-                }
-                // The properties of a union type are those that are present in all constituent types, so
-                // we only need to check the properties of the first type
-                if (type.flags & TypeFlags.Union) {
-                    break;
-                }
-            }
-            const props = type.resolvedProperties;
-            if (props) {
-                const result: Symbol[] = [];
-                props.forEach(prop => {
-                    // We need to filter out partial properties in union types
-                    if (!(prop.flags & SymbolFlags.SyntheticProperty && (<TransientSymbol>prop).isPartial)) {
-                        result.push(prop);
+            if (!type.resolvedProperties) {
+                const members = createMap<Symbol>();
+                for (const current of type.types) {
+                    for (const prop of getPropertiesOfType(current)) {
+                        if (!members.has(prop.name)) {
+                            const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.name);
+                            if (combinedProp) {
+                                members.set(prop.name, combinedProp);
+                            }
+                        }
                     }
-                });
-                return result;
+                    // The properties of a union type are those that are present in all constituent types, so
+                    // we only need to check the properties of the first type
+                    if (type.flags & TypeFlags.Union) {
+                        break;
+                    }
+                }
+                type.resolvedProperties = getNamedMembers(members);
             }
-            return emptyArray;
+            return type.resolvedProperties;
         }
 
         function getPropertiesOfType(type: Type): Symbol[] {
@@ -4943,7 +4941,7 @@ namespace ts {
         // these partial properties when identifying discriminant properties, but otherwise they are filtered out
         // and do not appear to be present in the union type.
         function getUnionOrIntersectionProperty(type: UnionOrIntersectionType, name: string): Symbol {
-            const properties = type.resolvedProperties || (type.resolvedProperties = createMap<Symbol>());
+            const properties = type.propertyCache || (type.propertyCache = createMap<Symbol>());
             let property = properties.get(name);
             if (!property) {
                 property = createUnionOrIntersectionProperty(type, name);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b834d73300a..65cd4031613 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2948,7 +2948,9 @@
     export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */
-        resolvedProperties: SymbolTable;  // Cache of resolved properties
+        propertyCache: SymbolTable;       // Cache of resolved properties
+        /* @internal */
+        resolvedProperties: Symbol[];
         /* @internal */
         resolvedIndexType: IndexType;
         /* @internal */

From c51e2867f50de63db151310da03b829d667becc9 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 19 Jan 2017 14:47:26 -0800
Subject: [PATCH 072/159] Allow object intersection types in class implements
 clauses

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1ca1cd9cf74..450fcfe1da4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -18411,8 +18411,7 @@ namespace ts {
                     if (produceDiagnostics) {
                         const t = getTypeFromTypeNode(typeRefNode);
                         if (t !== unknownType) {
-                            const declaredType = getObjectFlags(t) & ObjectFlags.Reference ? (<TypeReference>t).target : t;
-                            if (getObjectFlags(declaredType) & ObjectFlags.ClassOrInterface) {
+                            if (isValidBaseType(t)) {
                                 checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(t, type.thisType), node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1);
                             }
                             else {

From f9a65e436c67b1da2e0a80274e1fba5a9afc6d61 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 19 Jan 2017 14:47:38 -0800
Subject: [PATCH 073/159] Accept new baselines

---
 .../reference/typeAliasesForObjectTypes.errors.txt        | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt b/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt
index d5bc01f93ba..b4ae5978049 100644
--- a/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt
+++ b/tests/baselines/reference/typeAliasesForObjectTypes.errors.txt
@@ -1,19 +1,13 @@
-tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(4,22): error TS2312: An interface may only extend a class or another interface.
-tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(5,21): error TS2422: A class may only implement another class or interface.
 tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(10,6): error TS2300: Duplicate identifier 'T2'.
 tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts(11,6): error TS2300: Duplicate identifier 'T2'.
 
 
-==== tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts (4 errors) ====
+==== tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts (2 errors) ====
     type T1 = { x: string }
     
     // An interface can be named in an extends or implements clause, but a type alias for an object type literal cannot.
     interface I1 extends T1 { y: string }
-                         ~~
-!!! error TS2312: An interface may only extend a class or another interface.
     class C1 implements T1 {
-                        ~~
-!!! error TS2422: A class may only implement another class or interface.
         x: string;
     }
     

From d11d03a06c189ffc744914e9c961c4875afea6bd Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Thu, 19 Jan 2017 17:36:16 -0800
Subject: [PATCH 074/159] Fix
 https://github.com/DefinitelyTyped/DefinitelyTyped/issues/14036:

Remove assert.
---
 src/compiler/checker.ts                       |  1 -
 .../reference/mergedDeclarations7.errors.txt  | 32 +++++++++++++++++++
 .../reference/mergedDeclarations7.js          | 28 ++++++++++++++++
 tests/cases/compiler/mergedDeclarations7.ts   | 21 ++++++++++++
 4 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 tests/baselines/reference/mergedDeclarations7.errors.txt
 create mode 100644 tests/baselines/reference/mergedDeclarations7.js
 create mode 100644 tests/cases/compiler/mergedDeclarations7.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 756a2b2d3b1..a376e091ca3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4172,7 +4172,6 @@ namespace ts {
         }
 
         function getDeclaredTypeOfSymbol(symbol: Symbol): Type {
-            Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0);
             if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
                 return getDeclaredTypeOfClassOrInterface(symbol);
             }
diff --git a/tests/baselines/reference/mergedDeclarations7.errors.txt b/tests/baselines/reference/mergedDeclarations7.errors.txt
new file mode 100644
index 00000000000..cd9b3a5e939
--- /dev/null
+++ b/tests/baselines/reference/mergedDeclarations7.errors.txt
@@ -0,0 +1,32 @@
+tests/cases/compiler/test.ts(4,5): error TS2322: Type 'PassportStatic' is not assignable to type 'Passport'.
+  Types of property 'use' are incompatible.
+    Type '() => PassportStatic' is not assignable to type '() => this'.
+      Type 'PassportStatic' is not assignable to type 'this'.
+
+
+==== tests/cases/compiler/passport.d.ts (0 errors) ====
+    declare module 'passport' {
+        namespace passport {
+            interface Passport {
+                use(): this;
+            }
+    
+            interface PassportStatic extends Passport {
+                Passport: {new(): Passport};
+            }
+        }
+    
+        const passport: passport.PassportStatic;
+        export = passport;
+    }
+    
+==== tests/cases/compiler/test.ts (1 errors) ====
+    import * as passport from "passport";
+    import { Passport } from "passport";
+    
+    let p: Passport = passport.use();
+        ~
+!!! error TS2322: Type 'PassportStatic' is not assignable to type 'Passport'.
+!!! error TS2322:   Types of property 'use' are incompatible.
+!!! error TS2322:     Type '() => PassportStatic' is not assignable to type '() => this'.
+!!! error TS2322:       Type 'PassportStatic' is not assignable to type 'this'.
\ No newline at end of file
diff --git a/tests/baselines/reference/mergedDeclarations7.js b/tests/baselines/reference/mergedDeclarations7.js
new file mode 100644
index 00000000000..e3d1ddc6e0e
--- /dev/null
+++ b/tests/baselines/reference/mergedDeclarations7.js
@@ -0,0 +1,28 @@
+//// [tests/cases/compiler/mergedDeclarations7.ts] ////
+
+//// [passport.d.ts]
+declare module 'passport' {
+    namespace passport {
+        interface Passport {
+            use(): this;
+        }
+
+        interface PassportStatic extends Passport {
+            Passport: {new(): Passport};
+        }
+    }
+
+    const passport: passport.PassportStatic;
+    export = passport;
+}
+
+//// [test.ts]
+import * as passport from "passport";
+import { Passport } from "passport";
+
+let p: Passport = passport.use();
+
+//// [test.js]
+"use strict";
+var passport = require("passport");
+var p = passport.use();
diff --git a/tests/cases/compiler/mergedDeclarations7.ts b/tests/cases/compiler/mergedDeclarations7.ts
new file mode 100644
index 00000000000..fc0945f4419
--- /dev/null
+++ b/tests/cases/compiler/mergedDeclarations7.ts
@@ -0,0 +1,21 @@
+// @filename: passport.d.ts
+declare module 'passport' {
+    namespace passport {
+        interface Passport {
+            use(): this;
+        }
+
+        interface PassportStatic extends Passport {
+            Passport: {new(): Passport};
+        }
+    }
+
+    const passport: passport.PassportStatic;
+    export = passport;
+}
+
+//@filename: test.ts
+import * as passport from "passport";
+import { Passport } from "passport";
+
+let p: Passport = passport.use();
\ No newline at end of file

From 21c2c0e78607cab6fac463b8b227d63189f1306f Mon Sep 17 00:00:00 2001
From: falsandtru <falsandtru@users.noreply.github.com>
Date: Fri, 20 Jan 2017 23:05:45 +0900
Subject: [PATCH 075/159] Fix regressions

---
 src/lib/es2015.collection.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts
index 6a2c43cd050..75a11b5eb17 100644
--- a/src/lib/es2015.collection.d.ts
+++ b/src/lib/es2015.collection.d.ts
@@ -4,7 +4,7 @@ interface Map<K, V> {
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
     readonly size: number;
 }
 
@@ -26,7 +26,7 @@ interface WeakMap<K, V> {
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
 }
 
 interface WeakMapConstructor {

From a9af10b030d2167ad7612a98df28f4084e95a005 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 20 Jan 2017 06:16:08 -0800
Subject: [PATCH 076/159] Intersections as their own 'this' type

---
 src/compiler/checker.ts | 16 ++++++++++++----
 src/compiler/core.ts    |  4 ++++
 src/compiler/types.ts   |  5 ++++-
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 450fcfe1da4..6de1b5aa624 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4326,10 +4326,13 @@ namespace ts {
 
         function getTypeWithThisArgument(type: Type, thisArgument?: Type): Type {
             if (getObjectFlags(type) & ObjectFlags.Reference) {
-                return createTypeReference((<TypeReference>type).target,
-                    concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
+                const target = (<TypeReference>type).target;
+                const typeArguments = (<TypeReference>type).typeArguments;
+                if (length(target.typeParameters) === length(typeArguments)) {
+                    return createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
+                }
             }
-            if (type.flags & TypeFlags.Intersection) {
+            else if (type.flags & TypeFlags.Intersection) {
                 return getIntersectionType(map((<IntersectionType>type).types, t => getTypeWithThisArgument(t, thisArgument)));
             }
             return type;
@@ -4858,6 +4861,10 @@ namespace ts {
             }
         }
 
+        function getApparentTypeOfIntersectionType(type: IntersectionType) {
+            return type.resolvedIndexType || (type.resolvedApparentType = getTypeWithThisArgument(type, type));
+        }
+
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
@@ -4865,7 +4872,8 @@ namespace ts {
          */
         function getApparentType(type: Type): Type {
             const t = type.flags & TypeFlags.TypeVariable ? getBaseConstraintOfType(<TypeVariable>type) || emptyObjectType : type;
-            return t.flags & TypeFlags.StringLike ? globalStringType :
+            return t.flags & TypeFlags.Intersection ? getApparentTypeOfIntersectionType(<IntersectionType>type) :
+                t.flags & TypeFlags.StringLike ? globalStringType :
                 t.flags & TypeFlags.NumberLike ? globalNumberType :
                 t.flags & TypeFlags.BooleanLike ? globalBooleanType :
                 t.flags & TypeFlags.ESSymbol ? getGlobalESSymbolType() :
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 654b1bc2912..47a6e2e70a8 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -202,6 +202,10 @@ namespace ts {
         GreaterThan = 1
     }
 
+    export function length(array: any[]) {
+        return array ? array.length : 0;
+    }
+
     /**
      * Iterates through 'array' by index and performs the callback on each element of array until the callback
      * returns a truthy value, then returns that value.
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 65cd4031613..6b5c670a9fa 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2961,7 +2961,10 @@
 
     export interface UnionType extends UnionOrIntersectionType { }
 
-    export interface IntersectionType extends UnionOrIntersectionType { }
+    export interface IntersectionType extends UnionOrIntersectionType {
+        /* @internal */
+        resolvedApparentType: Type;
+    }
 
     export type StructuredType = ObjectType | UnionType | IntersectionType;
 

From 1267fd3030a588eb29dcf7ad0e4bb3c8887a59fb Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 20 Jan 2017 06:41:57 -0800
Subject: [PATCH 077/159] Don't use nameTable for type keywords, and don't
 handle keyof.

---
 src/services/findAllReferences.ts             |  4 +---
 src/services/services.ts                      | 17 ++++-------------
 src/services/utilities.ts                     |  3 +--
 tests/cases/fourslash/findAllRefsPrimitive.ts |  2 --
 4 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 68eb684fe25..82a5da453b7 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -353,9 +353,7 @@ namespace ts.FindAllReferences {
         const references: ReferenceEntry[] = [];
         for (const sourceFile of sourceFiles) {
             cancellationToken.throwIfCancellationRequested();
-            if (sourceFileHasName(sourceFile, name)) {
-                addReferencesForKeywordInFile(sourceFile, keywordKind, name, cancellationToken, references);
-            }
+            addReferencesForKeywordInFile(sourceFile, keywordKind, name, cancellationToken, references);
         }
 
         return [{ definition, references }];
diff --git a/src/services/services.ts b/src/services/services.ts
index 20204165328..1fe2235a4ba 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1975,20 +1975,11 @@ namespace ts {
                         setNameTable((<LiteralExpression>node).text, node);
                     }
                     break;
-                case SyntaxKind.TypeOperator:
-                    setNameTable(tokenToString((node as ts.TypeOperatorNode).operator), node);
-                    forEachChild(node, walk);
-                    break;
                 default:
-                    if (isTypeKeyword(node.kind)) {
-                        setNameTable(tokenToString(node.kind), node);
-                    }
-                    else {
-                        forEachChild(node, walk);
-                        if (node.jsDoc) {
-                            for (const jsDoc of node.jsDoc) {
-                                forEachChild(jsDoc, walk);
-                            }
+                    forEachChild(node, walk);
+                    if (node.jsDoc) {
+                        for (const jsDoc of node.jsDoc) {
+                            forEachChild(jsDoc, walk);
                         }
                     }
             }
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index dd337238da3..a1680da69c3 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -1,4 +1,4 @@
-// These utilities are common to multiple language service features.
+// These utilities are common to multiple language service features.
 /* @internal */
 namespace ts {
     export const scanner: Scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
@@ -1126,7 +1126,6 @@ namespace ts {
             case SyntaxKind.BooleanKeyword:
             case SyntaxKind.NeverKeyword:
             case SyntaxKind.NumberKeyword:
-            case SyntaxKind.KeyOfKeyword:
             case SyntaxKind.ObjectKeyword:
             case SyntaxKind.StringKeyword:
             case SyntaxKind.SymbolKeyword:
diff --git a/tests/cases/fourslash/findAllRefsPrimitive.ts b/tests/cases/fourslash/findAllRefsPrimitive.ts
index 9bd3d62eabb..51c463843e1 100644
--- a/tests/cases/fourslash/findAllRefsPrimitive.ts
+++ b/tests/cases/fourslash/findAllRefsPrimitive.ts
@@ -21,8 +21,6 @@
 
 ////function v(v: [|void|]): [|void|];
 
-////function k(x: [|keyof|] Date): [|keyof|] Date;
-
 // @Filename: b.ts
 // const z: [|any|] = 0;
 

From c16c7d56c0a4e9f7e11dd134cffcdbb1eef5916c Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 20 Jan 2017 09:17:14 -0800
Subject: [PATCH 078/159] Allow base constructor types to be intersections

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6de1b5aa624..a5058bdf7f2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3810,7 +3810,7 @@ namespace ts {
         }
 
         function isConstructorType(type: Type): boolean {
-            return type.flags & TypeFlags.Object && getSignaturesOfType(type, SignatureKind.Construct).length > 0;
+            return isValidBaseType(type) && getSignaturesOfType(type, SignatureKind.Construct).length > 0;
         }
 
         function getBaseTypeNodeOfClass(type: InterfaceType): ExpressionWithTypeArguments {
@@ -3849,7 +3849,7 @@ namespace ts {
                     return unknownType;
                 }
                 const baseConstructorType = checkExpression(baseTypeNode.expression);
-                if (baseConstructorType.flags & TypeFlags.Object) {
+                if (baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection)) {
                     // Resolving the members of a class requires us to resolve the base class of that class.
                     // We force resolution here such that we catch circularities now.
                     resolveStructuredTypeMembers(<ObjectType>baseConstructorType);
@@ -3890,7 +3890,7 @@ namespace ts {
         function resolveBaseTypesOfClass(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
             const baseConstructorType = <ObjectType>getBaseConstructorTypeOfClass(type);
-            if (!(baseConstructorType.flags & TypeFlags.Object)) {
+            if (!(baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection))) {
                 return;
             }
             const baseTypeNode = getBaseTypeNodeOfClass(type);
@@ -4591,9 +4591,9 @@ namespace ts {
                         constructSignatures = getDefaultConstructSignatures(classType);
                     }
                     const baseConstructorType = getBaseConstructorTypeOfClass(classType);
-                    if (baseConstructorType.flags & TypeFlags.Object) {
+                    if (baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection)) {
                         members = createSymbolTable(getNamedMembers(members));
-                        addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType));
+                        addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
                     }
                 }
                 const numberIndexInfo = symbol.flags & SymbolFlags.Enum ? enumNumberIndexInfo : undefined;

From 1183129bda17ff969334b1f1a055d463f8028535 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Fri, 20 Jan 2017 10:17:11 -0800
Subject: [PATCH 079/159] getFirstToken returns jsdoc as single comment

This is a bit odd, but it's the way that 2.0 and earlier behaved. 2.1
broke it.
---
 src/compiler/types.ts                 |  2 +-
 src/harness/unittests/jsDocParsing.ts | 14 ++++++++++++++
 src/services/services.ts              |  9 ++++++---
 3 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 51347c8d3df..f0e20ecd4bf 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -421,7 +421,7 @@
         LastBinaryOperator = CaretEqualsToken,
         FirstNode = QualifiedName,
         FirstJSDocNode = JSDocTypeExpression,
-        LastJSDocNode = JSDocLiteralType,
+        LastJSDocNode = JSDocNeverKeyword,
         FirstJSDocTagNode = JSDocComment,
         LastJSDocTagNode = JSDocNeverKeyword
     }
diff --git a/src/harness/unittests/jsDocParsing.ts b/src/harness/unittests/jsDocParsing.ts
index addd01b0e0a..3cafc9d49ae 100644
--- a/src/harness/unittests/jsDocParsing.ts
+++ b/src/harness/unittests/jsDocParsing.ts
@@ -288,5 +288,19 @@ namespace ts {
   */`);
             });
         });
+        describe("getFirstToken", () => {
+            it("gets jsdoc", () => {
+                const first = ts.createSourceFile("foo.ts", "/** comment */var a = true;", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                assert.isDefined(first);
+                assert.equal(first.kind, 263);
+            });
+        });
+        describe("getLastToken", () => {
+            it("gets jsdoc", () => {
+                const last = ts.createSourceFile("foo.ts", "var a = true;/** comment */", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                assert.isDefined(last);
+                assert.equal(last.kind, 263);
+            });
+        });
     });
 }
diff --git a/src/services/services.ts b/src/services/services.ts
index 26374eccbfd..cdd789166bc 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -194,8 +194,9 @@ namespace ts {
             }
 
             const child = children[0];
-
-            return child.kind < SyntaxKind.FirstNode ? child : child.getFirstToken(sourceFile);
+            return child.kind < SyntaxKind.FirstNode || SyntaxKind.FirstJSDocNode <= child.kind && child.kind <= SyntaxKind.LastJSDocNode ?
+                child :
+                child.getFirstToken(sourceFile);
         }
 
         public getLastToken(sourceFile?: SourceFile): Node {
@@ -206,7 +207,9 @@ namespace ts {
                 return undefined;
             }
 
-            return child.kind < SyntaxKind.FirstNode ? child : child.getLastToken(sourceFile);
+            return child.kind < SyntaxKind.FirstNode || SyntaxKind.FirstJSDocNode <= child.kind && child.kind <= SyntaxKind.LastJSDocNode ?
+                child :
+                child.getLastToken(sourceFile);
         }
     }
 

From 8886cefe58c4674589f8f96067effcbb3dc77aa8 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 20 Jan 2017 08:12:00 -0800
Subject: [PATCH 080/159] Clean up code for getting emitted files

---
 src/compiler/emitter.ts                       |   4 +-
 src/compiler/program.ts                       |   2 +-
 src/compiler/utilities.ts                     | 186 +++++-------------
 .../reference/noBundledEmitFromNodeModules.js |  20 ++
 .../noBundledEmitFromNodeModules.symbols      |   9 +
 .../noBundledEmitFromNodeModules.types        |   9 +
 .../compiler/noBundledEmitFromNodeModules.ts  |  10 +
 7 files changed, 98 insertions(+), 142 deletions(-)
 create mode 100644 tests/baselines/reference/noBundledEmitFromNodeModules.js
 create mode 100644 tests/baselines/reference/noBundledEmitFromNodeModules.symbols
 create mode 100644 tests/baselines/reference/noBundledEmitFromNodeModules.types
 create mode 100644 tests/cases/compiler/noBundledEmitFromNodeModules.ts

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 2ff342138c8..1c4662fa587 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -73,7 +73,7 @@ namespace ts {
 
         // Emit each output file
         performance.mark("beforePrint");
-        forEachTransformedEmitFile(host, transformed, emitFile, emitOnlyDtsFiles);
+        forEachEmittedFile(host, transformed, emitFile, emitOnlyDtsFiles);
         performance.measure("printTime", "beforePrint");
 
         // Clean up emit nodes on parse tree
@@ -88,7 +88,7 @@ namespace ts {
             sourceMaps: sourceMapDataList
         };
 
-        function emitFile(jsFilePath: string, sourceMapFilePath: string, declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {
+        function emitFile({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean) {
             // Make sure not to write js file and source map file if any of them cannot be written
             if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit) {
                 if (!emitOnlyDtsFiles) {
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 324a21f229e..851e206d448 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -439,7 +439,7 @@ namespace ts {
 
         function getCommonSourceDirectory() {
             if (commonSourceDirectory === undefined) {
-                const emittedFiles = filterSourceFilesInDirectory(files, isSourceFileFromExternalLibrary);
+                const emittedFiles = filter(files, file => sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary));
                 if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) {
                     // If a rootDir is specified and is valid use it as the commonSourceDirectory
                     commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 932e75d0345..f59d384e490 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2568,108 +2568,25 @@ namespace ts {
      * @param host An EmitHost.
      * @param targetSourceFile An optional target source file to emit.
      */
-    export function getSourceFilesToEmit(host: EmitHost, targetSourceFile?: SourceFile) {
+    export function getSourceFilesToEmit(host: EmitHost, targetSourceFile?: SourceFile): SourceFile[] {
         const options = host.getCompilerOptions();
+        const isSourceFileFromExternalLibrary = (file: SourceFile) => host.isSourceFileFromExternalLibrary(file);
         if (options.outFile || options.out) {
             const moduleKind = getEmitModuleKind(options);
             const moduleEmitEnabled = moduleKind === ModuleKind.AMD || moduleKind === ModuleKind.System;
-            const sourceFiles = getAllEmittableSourceFiles();
             // Can emit only sources that are not declaration file and are either non module code or module with --module or --target es6 specified
-            return filter(sourceFiles, moduleEmitEnabled ? isNonDeclarationFile : isBundleEmitNonExternalModule);
+            return filter(host.getSourceFiles(), sourceFile =>
+                (moduleEmitEnabled || !isExternalModule(sourceFile)) && sourceFileMayBeEmitted(sourceFile, options, isSourceFileFromExternalLibrary));
         }
         else {
-            const sourceFiles = targetSourceFile === undefined ? getAllEmittableSourceFiles() : [targetSourceFile];
-            return filterSourceFilesInDirectory(sourceFiles, file => host.isSourceFileFromExternalLibrary(file));
-        }
-
-        function getAllEmittableSourceFiles() {
-            return options.noEmitForJsFiles ? filter(host.getSourceFiles(), sourceFile => !isSourceFileJavaScript(sourceFile)) : host.getSourceFiles();
+            const sourceFiles = targetSourceFile === undefined ? host.getSourceFiles() : [targetSourceFile];
+            return filter(sourceFiles, sourceFile => sourceFileMayBeEmitted(sourceFile, options, isSourceFileFromExternalLibrary));
         }
     }
 
-    /** Don't call this for `--outFile`, just for `--outDir` or plain emit. */
-    export function filterSourceFilesInDirectory(sourceFiles: SourceFile[], isSourceFileFromExternalLibrary: (file: SourceFile) => boolean): SourceFile[] {
-        return filter(sourceFiles, file => shouldEmitInDirectory(file, isSourceFileFromExternalLibrary));
-    }
-
-    function isNonDeclarationFile(sourceFile: SourceFile) {
-        return !isDeclarationFile(sourceFile);
-    }
-
-    /**
-     * Whether a file should be emitted in a non-`--outFile` case.
-     * Don't emit if source file is a declaration file, or was located under node_modules
-     */
-    function shouldEmitInDirectory(sourceFile: SourceFile, isSourceFileFromExternalLibrary: (file: SourceFile) => boolean): boolean {
-        return isNonDeclarationFile(sourceFile) && !isSourceFileFromExternalLibrary(sourceFile);
-    }
-
-    function isBundleEmitNonExternalModule(sourceFile: SourceFile) {
-        return isNonDeclarationFile(sourceFile) && !isExternalModule(sourceFile);
-    }
-
-    /**
-     * Iterates over each source file to emit. The source files are expected to have been
-     * transformed for use by the pretty printer.
-     *
-     * Originally part of `forEachExpectedEmitFile`, this functionality was extracted to support
-     * transformations.
-     *
-     * @param host An EmitHost.
-     * @param sourceFiles The transformed source files to emit.
-     * @param action The action to execute.
-     */
-    export function forEachTransformedEmitFile(host: EmitHost, sourceFiles: SourceFile[],
-        action: (jsFilePath: string, sourceMapFilePath: string, declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) => void,
-        emitOnlyDtsFiles?: boolean) {
-        const options = host.getCompilerOptions();
-        // Emit on each source file
-        if (options.outFile || options.out) {
-            onBundledEmit(sourceFiles);
-        }
-        else {
-            for (const sourceFile of sourceFiles) {
-                // Don't emit if source file is a declaration file, or was located under node_modules
-                if (!isDeclarationFile(sourceFile) && !host.isSourceFileFromExternalLibrary(sourceFile)) {
-                    onSingleFileEmit(host, sourceFile);
-                }
-            }
-        }
-
-        function onSingleFileEmit(host: EmitHost, sourceFile: SourceFile) {
-            // JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.
-            // So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.
-            // For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve
-            let extension = ".js";
-            if (options.jsx === JsxEmit.Preserve) {
-                if (isSourceFileJavaScript(sourceFile)) {
-                    if (fileExtensionIs(sourceFile.fileName, ".jsx")) {
-                        extension = ".jsx";
-                    }
-                }
-                else if (sourceFile.languageVariant === LanguageVariant.JSX) {
-                    // TypeScript source file preserving JSX syntax
-                    extension = ".jsx";
-                }
-            }
-            const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, extension);
-            const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
-            const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (options.declaration || emitOnlyDtsFiles) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;
-            action(jsFilePath, sourceMapFilePath, declarationFilePath, [sourceFile], /*isBundledEmit*/ false);
-        }
-
-        function onBundledEmit(sourceFiles: SourceFile[]) {
-            if (sourceFiles.length) {
-                const jsFilePath = options.outFile || options.out;
-                const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
-                const declarationFilePath = options.declaration ? removeFileExtension(jsFilePath) + ".d.ts" : undefined;
-                action(jsFilePath, sourceMapFilePath, declarationFilePath, sourceFiles, /*isBundledEmit*/ true);
-            }
-        }
-    }
-
-    function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions) {
-        return options.sourceMap ? jsFilePath + ".map" : undefined;
+    /** Don't call this for `--outFile`, just for `--outDir` or plain emit. `--outFile` needs additional checks. */
+    export function sourceFileMayBeEmitted(sourceFile: SourceFile, options: CompilerOptions, isSourceFileFromExternalLibrary: (file: SourceFile) => boolean) {
+        return !(options.noEmitForJsFiles && isSourceFileJavaScript(sourceFile)) && !isDeclarationFile(sourceFile) && !isSourceFileFromExternalLibrary(sourceFile);
     }
 
     /**
@@ -2685,64 +2602,55 @@ namespace ts {
         action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
         targetSourceFile?: SourceFile,
         emitOnlyDtsFiles?: boolean) {
+        forEachEmittedFile(host, getSourceFilesToEmit(host, targetSourceFile), action, emitOnlyDtsFiles);
+    }
+
+    /**
+     * Iterates over each source file to emit.
+     */
+    export function forEachEmittedFile(host: EmitHost, sourceFiles: SourceFile[],
+        action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
+        emitOnlyDtsFiles?: boolean) {
         const options = host.getCompilerOptions();
-        // Emit on each source file
         if (options.outFile || options.out) {
-            onBundledEmit(host);
+            if (sourceFiles.length) {
+                const jsFilePath = options.outFile || options.out;
+                const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
+                const declarationFilePath = options.declaration ? removeFileExtension(jsFilePath) + ".d.ts" : undefined;
+                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, sourceFiles, /*isBundledEmit*/true, emitOnlyDtsFiles);
+            }
         }
         else {
-            const sourceFiles = targetSourceFile === undefined ? getSourceFilesToEmit(host) : [targetSourceFile];
             for (const sourceFile of sourceFiles) {
-                if (shouldEmitInDirectory(sourceFile, file => host.isSourceFileFromExternalLibrary(file))) {
-                    onSingleFileEmit(host, sourceFile);
-                }
+                const options = host.getCompilerOptions();
+                const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, getOutputExtension(sourceFile, options));
+                const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
+                const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (emitOnlyDtsFiles || options.declaration) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;
+                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, [sourceFile], /*isBundledEmit*/false, emitOnlyDtsFiles);
             }
         }
+    }
 
-        function onSingleFileEmit(host: EmitHost, sourceFile: SourceFile) {
-            // JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.
-            // So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.
-            // For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve
-            let extension = ".js";
-            if (options.jsx === JsxEmit.Preserve) {
-                if (isSourceFileJavaScript(sourceFile)) {
-                    if (fileExtensionIs(sourceFile.fileName, ".jsx")) {
-                        extension = ".jsx";
-                    }
-                }
-                else if (sourceFile.languageVariant === LanguageVariant.JSX) {
-                    // TypeScript source file preserving JSX syntax
-                    extension = ".jsx";
-                }
-            }
-            const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, extension);
-            const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (emitOnlyDtsFiles || options.declaration) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;
-            const emitFileNames: EmitFileNames = {
-                jsFilePath,
-                sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
-                declarationFilePath
-            };
-            action(emitFileNames, [sourceFile], /*isBundledEmit*/false, emitOnlyDtsFiles);
-        }
+    function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions) {
+        return options.sourceMap ? jsFilePath + ".map" : undefined;
+    }
 
-        function onBundledEmit(host: EmitHost) {
-            // Can emit only sources that are not declaration file and are either non module code or module with
-            // --module or --target es6 specified. Files included by searching under node_modules are also not emitted.
-            const bundledSources = filter(getSourceFilesToEmit(host),
-                sourceFile => !isDeclarationFile(sourceFile) &&
-                    !host.isSourceFileFromExternalLibrary(sourceFile) &&
-                    (!isExternalModule(sourceFile) ||
-                        !!getEmitModuleKind(options)));
-            if (bundledSources.length) {
-                const jsFilePath = options.outFile || options.out;
-                const emitFileNames: EmitFileNames = {
-                    jsFilePath,
-                    sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
-                    declarationFilePath: options.declaration ? removeFileExtension(jsFilePath) + ".d.ts" : undefined
-                };
-                action(emitFileNames, bundledSources, /*isBundledEmit*/true, emitOnlyDtsFiles);
+    // JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.
+    // So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.
+    // For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve
+    function getOutputExtension(sourceFile: SourceFile, options: CompilerOptions): string {
+        if (options.jsx === JsxEmit.Preserve) {
+            if (isSourceFileJavaScript(sourceFile)) {
+                if (fileExtensionIs(sourceFile.fileName, ".jsx")) {
+                    return ".jsx";
+                }
+            }
+            else if (sourceFile.languageVariant === LanguageVariant.JSX) {
+                // TypeScript source file preserving JSX syntax
+                return ".jsx";
             }
         }
+        return ".js";
     }
 
     export function getSourceFilePathInNewDir(sourceFile: SourceFile, host: EmitHost, newDirPath: string) {
diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.js b/tests/baselines/reference/noBundledEmitFromNodeModules.js
new file mode 100644
index 00000000000..67216a408af
--- /dev/null
+++ b/tests/baselines/reference/noBundledEmitFromNodeModules.js
@@ -0,0 +1,20 @@
+//// [tests/cases/compiler/noBundledEmitFromNodeModules.ts] ////
+
+//// [index.ts]
+
+export class C {}
+
+//// [a.ts]
+import { C } from "projB";
+
+
+//// [out.js]
+System.register("a", [], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    return {
+        setters: [],
+        execute: function () {
+        }
+    };
+});
diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.symbols b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols
new file mode 100644
index 00000000000..a1f6c67e4b4
--- /dev/null
+++ b/tests/baselines/reference/noBundledEmitFromNodeModules.symbols
@@ -0,0 +1,9 @@
+=== /a.ts ===
+import { C } from "projB";
+>C : Symbol(C, Decl(a.ts, 0, 8))
+
+=== /node_modules/projB/index.ts ===
+
+export class C {}
+>C : Symbol(C, Decl(index.ts, 0, 0))
+
diff --git a/tests/baselines/reference/noBundledEmitFromNodeModules.types b/tests/baselines/reference/noBundledEmitFromNodeModules.types
new file mode 100644
index 00000000000..a11bad24aaf
--- /dev/null
+++ b/tests/baselines/reference/noBundledEmitFromNodeModules.types
@@ -0,0 +1,9 @@
+=== /a.ts ===
+import { C } from "projB";
+>C : typeof C
+
+=== /node_modules/projB/index.ts ===
+
+export class C {}
+>C : C
+
diff --git a/tests/cases/compiler/noBundledEmitFromNodeModules.ts b/tests/cases/compiler/noBundledEmitFromNodeModules.ts
new file mode 100644
index 00000000000..66c71a58489
--- /dev/null
+++ b/tests/cases/compiler/noBundledEmitFromNodeModules.ts
@@ -0,0 +1,10 @@
+// @outFile: out.js
+// @module: system
+// @moduleResolution: node
+// @noImplicitReferences: true
+
+// @fileName: /node_modules/projB/index.ts
+export class C {}
+
+// @fileName: /a.ts
+import { C } from "projB";

From 108d8cf584406824a569cc4b18428d5dc26cbdd1 Mon Sep 17 00:00:00 2001
From: Basarat Ali Syed <basaratali@gmail.com>
Date: Sat, 21 Jan 2017 11:36:18 +1100
Subject: [PATCH 081/159] export the type `Log` that is used by exported
 functions

closes https://github.com/Microsoft/TypeScript/issues/13559
---
 src/services/completions.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/services/completions.ts b/src/services/completions.ts
index d6d3a9ce060..5a08dbcb9c8 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -1,6 +1,6 @@
 /* @internal */
 namespace ts.Completions {
-    type Log = (message: string) => void;
+    export type Log = (message: string) => void;
 
     export function getCompletionsAtPosition(host: LanguageServiceHost, typeChecker: TypeChecker, log: Log, compilerOptions: CompilerOptions, sourceFile: SourceFile, position: number): CompletionInfo | undefined {
         if (isInReferenceComment(sourceFile, position)) {

From 4ee8213dde3a08b29d3add176cae92bdb20c5415 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Fri, 20 Jan 2017 19:59:26 -0800
Subject: [PATCH 082/159] do not capture 'arguments' when property name
 'arguments' is met (#13600)

do not capture 'arguments' when property name 'arguments' is met
---
 src/compiler/checker.ts                       |  3 +-
 src/compiler/transformers/es2015.ts           |  2 +-
 .../reference/argumentsAsPropertyName.js      | 29 ++++++++++
 .../reference/argumentsAsPropertyName.symbols | 43 ++++++++++++++
 .../reference/argumentsAsPropertyName.types   | 57 +++++++++++++++++++
 .../cases/compiler/argumentsAsPropertyName.ts | 15 +++++
 6 files changed, 147 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/argumentsAsPropertyName.js
 create mode 100644 tests/baselines/reference/argumentsAsPropertyName.symbols
 create mode 100644 tests/baselines/reference/argumentsAsPropertyName.types
 create mode 100644 tests/cases/compiler/argumentsAsPropertyName.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a1ad9f0344d..5f80444c73e 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -20222,7 +20222,8 @@ namespace ts {
             if (!isGeneratedIdentifier(node)) {
                 node = getParseTreeNode(node, isIdentifier);
                 if (node) {
-                    return getReferencedValueSymbol(node) === argumentsSymbol;
+                    const isPropertyName = node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node;
+                    return !isPropertyName && getReferencedValueSymbol(node) === argumentsSymbol;
                 }
             }
 
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index d0b9ef7455f..d1dab8eeb7a 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -585,7 +585,7 @@ namespace ts {
             if (isGeneratedIdentifier(node)) {
                 return node;
             }
-            if (node.text !== "arguments" && !resolver.isArgumentsLocalBinding(node)) {
+            if (node.text !== "arguments" || !resolver.isArgumentsLocalBinding(node)) {
                 return node;
             }
             return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = createUniqueName("arguments"));
diff --git a/tests/baselines/reference/argumentsAsPropertyName.js b/tests/baselines/reference/argumentsAsPropertyName.js
new file mode 100644
index 00000000000..a4197c0a1d2
--- /dev/null
+++ b/tests/baselines/reference/argumentsAsPropertyName.js
@@ -0,0 +1,29 @@
+//// [argumentsAsPropertyName.ts]
+// target: es5
+type MyType = {
+    arguments: Array<string>
+}
+
+declare function use(s: any);
+
+function myFunction(myType: MyType) {
+    for (let i = 0; i < 10; i++) {
+        use(myType.arguments[i]);
+        // create closure so that tsc will turn loop body into function
+        const x = 5;
+        [1, 2, 3].forEach(function(j) { use(x); })
+    }
+}
+
+//// [argumentsAsPropertyName.js]
+function myFunction(myType) {
+    var _loop_1 = function (i) {
+        use(myType.arguments[i]);
+        // create closure so that tsc will turn loop body into function
+        var x = 5;
+        [1, 2, 3].forEach(function (j) { use(x); });
+    };
+    for (var i = 0; i < 10; i++) {
+        _loop_1(i);
+    }
+}
diff --git a/tests/baselines/reference/argumentsAsPropertyName.symbols b/tests/baselines/reference/argumentsAsPropertyName.symbols
new file mode 100644
index 00000000000..1e3e41abb6e
--- /dev/null
+++ b/tests/baselines/reference/argumentsAsPropertyName.symbols
@@ -0,0 +1,43 @@
+=== tests/cases/compiler/argumentsAsPropertyName.ts ===
+// target: es5
+type MyType = {
+>MyType : Symbol(MyType, Decl(argumentsAsPropertyName.ts, 0, 0))
+
+    arguments: Array<string>
+>arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+}
+
+declare function use(s: any);
+>use : Symbol(use, Decl(argumentsAsPropertyName.ts, 3, 1))
+>s : Symbol(s, Decl(argumentsAsPropertyName.ts, 5, 21))
+
+function myFunction(myType: MyType) {
+>myFunction : Symbol(myFunction, Decl(argumentsAsPropertyName.ts, 5, 29))
+>myType : Symbol(myType, Decl(argumentsAsPropertyName.ts, 7, 20))
+>MyType : Symbol(MyType, Decl(argumentsAsPropertyName.ts, 0, 0))
+
+    for (let i = 0; i < 10; i++) {
+>i : Symbol(i, Decl(argumentsAsPropertyName.ts, 8, 12))
+>i : Symbol(i, Decl(argumentsAsPropertyName.ts, 8, 12))
+>i : Symbol(i, Decl(argumentsAsPropertyName.ts, 8, 12))
+
+        use(myType.arguments[i]);
+>use : Symbol(use, Decl(argumentsAsPropertyName.ts, 3, 1))
+>myType.arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>myType : Symbol(myType, Decl(argumentsAsPropertyName.ts, 7, 20))
+>arguments : Symbol(arguments, Decl(argumentsAsPropertyName.ts, 1, 15))
+>i : Symbol(i, Decl(argumentsAsPropertyName.ts, 8, 12))
+
+        // create closure so that tsc will turn loop body into function
+        const x = 5;
+>x : Symbol(x, Decl(argumentsAsPropertyName.ts, 11, 13))
+
+        [1, 2, 3].forEach(function(j) { use(x); })
+>[1, 2, 3].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>j : Symbol(j, Decl(argumentsAsPropertyName.ts, 12, 35))
+>use : Symbol(use, Decl(argumentsAsPropertyName.ts, 3, 1))
+>x : Symbol(x, Decl(argumentsAsPropertyName.ts, 11, 13))
+    }
+}
diff --git a/tests/baselines/reference/argumentsAsPropertyName.types b/tests/baselines/reference/argumentsAsPropertyName.types
new file mode 100644
index 00000000000..d0aaaa1cc72
--- /dev/null
+++ b/tests/baselines/reference/argumentsAsPropertyName.types
@@ -0,0 +1,57 @@
+=== tests/cases/compiler/argumentsAsPropertyName.ts ===
+// target: es5
+type MyType = {
+>MyType : MyType
+
+    arguments: Array<string>
+>arguments : string[]
+>Array : T[]
+}
+
+declare function use(s: any);
+>use : (s: any) => any
+>s : any
+
+function myFunction(myType: MyType) {
+>myFunction : (myType: MyType) => void
+>myType : MyType
+>MyType : MyType
+
+    for (let i = 0; i < 10; i++) {
+>i : number
+>0 : 0
+>i < 10 : boolean
+>i : number
+>10 : 10
+>i++ : number
+>i : number
+
+        use(myType.arguments[i]);
+>use(myType.arguments[i]) : any
+>use : (s: any) => any
+>myType.arguments[i] : string
+>myType.arguments : string[]
+>myType : MyType
+>arguments : string[]
+>i : number
+
+        // create closure so that tsc will turn loop body into function
+        const x = 5;
+>x : 5
+>5 : 5
+
+        [1, 2, 3].forEach(function(j) { use(x); })
+>[1, 2, 3].forEach(function(j) { use(x); }) : void
+>[1, 2, 3].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>[1, 2, 3] : number[]
+>1 : 1
+>2 : 2
+>3 : 3
+>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>function(j) { use(x); } : (j: number) => void
+>j : number
+>use(x) : any
+>use : (s: any) => any
+>x : 5
+    }
+}
diff --git a/tests/cases/compiler/argumentsAsPropertyName.ts b/tests/cases/compiler/argumentsAsPropertyName.ts
new file mode 100644
index 00000000000..ffecdaa1301
--- /dev/null
+++ b/tests/cases/compiler/argumentsAsPropertyName.ts
@@ -0,0 +1,15 @@
+// target: es5
+type MyType = {
+    arguments: Array<string>
+}
+
+declare function use(s: any);
+
+function myFunction(myType: MyType) {
+    for (let i = 0; i < 10; i++) {
+        use(myType.arguments[i]);
+        // create closure so that tsc will turn loop body into function
+        const x = 5;
+        [1, 2, 3].forEach(function(j) { use(x); })
+    }
+}
\ No newline at end of file

From 7d773f18e09de59fc49090307b5980529fe97d0d Mon Sep 17 00:00:00 2001
From: Tingan Ho <tingan87@gmail.com>
Date: Sat, 21 Jan 2017 17:07:37 +0100
Subject: [PATCH 083/159] Adds non-ambient context check

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5f80444c73e..2cac77bf576 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -18337,7 +18337,11 @@ namespace ts {
             const staticType = <ObjectType>getTypeOfSymbol(symbol);
             checkTypeParameterListsIdentical(node, symbol);
             checkClassForDuplicateDeclarations(node);
+
+            // Only check for reserved static identifiers on non-ambient context.
+            if (!isInAmbientContext(node)) {
             checkClassForStaticPropertyNameConflicts(node);
+            }
 
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {

From 02af00fae7ce4ad63ffa9a566e6f46d48e7ca333 Mon Sep 17 00:00:00 2001
From: Tingan Ho <tingan87@gmail.com>
Date: Sat, 21 Jan 2017 17:08:48 +0100
Subject: [PATCH 084/159] Fixes formatting

---
 src/compiler/checker.ts                       |  12 +-
 ...pertyNameConflictsInAmbientContext.symbols | 107 ++++++++++++++++++
 2 files changed, 113 insertions(+), 6 deletions(-)
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2cac77bf576..383b92b7074 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -15722,12 +15722,12 @@ namespace ts {
             }
         }
 
-        /** 
+        /**
          * Static members being set on a constructor function may conflict with built-in properties
-         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable 
-         * built-in properties. This check issues a transpile error when a class has a static 
+         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable
+         * built-in properties. This check issues a transpile error when a class has a static
          * member with the same name as a non-writable built-in property.
-         * 
+         *
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
          * @see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
@@ -18340,7 +18340,7 @@ namespace ts {
 
             // Only check for reserved static identifiers on non-ambient context.
             if (!isInAmbientContext(node)) {
-            checkClassForStaticPropertyNameConflicts(node);
+                checkClassForStaticPropertyNameConflicts(node);
             }
 
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols
new file mode 100644
index 00000000000..46297eab86a
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols
@@ -0,0 +1,107 @@
+=== tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts ===
+
+// name
+declare class StaticName {
+>StaticName : Symbol(StaticName, Decl(decl.d.ts, 0, 0))
+
+    static name: number; // ok
+>name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 26))
+
+    name: string; // ok
+>name : Symbol(StaticName.name, Decl(decl.d.ts, 3, 24))
+}
+
+declare class StaticNameFn {
+>StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 5, 1))
+
+    static name(): string; // ok
+>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 28))
+
+    name(): string; // ok
+>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 8, 26))
+}
+
+// length
+declare class StaticLength {
+>StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 10, 1))
+
+    static length: number; // ok
+>length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 28))
+
+    length: string; // ok
+>length : Symbol(StaticLength.length, Decl(decl.d.ts, 14, 26))
+}
+
+declare class StaticLengthFn {
+>StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 16, 1))
+
+    static length(): number; // ok
+>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 30))
+
+    length(): number; // ok
+>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 19, 28))
+}
+
+// prototype
+declare class StaticPrototype {
+>StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 21, 1))
+
+    static prototype: number; // ok
+>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 31))
+
+    prototype: string; // ok
+>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 25, 29))
+}
+
+declare class StaticPrototypeFn {
+>StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 27, 1))
+
+    static prototype: any; // ok
+>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 33))
+
+    prototype(): any; // ok
+>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 30, 26))
+}
+
+// caller
+declare class StaticCaller {
+>StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 32, 1))
+
+    static caller: number; // ok
+>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 28))
+
+    caller: string; // ok
+>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 36, 26))
+}
+
+declare class StaticCallerFn {
+>StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 38, 1))
+
+    static caller(): any; // ok
+>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 30))
+
+    caller(): any; // ok
+>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 41, 25))
+}
+
+// arguments
+declare class StaticArguments {
+>StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 43, 1))
+
+    static arguments: number; // ok
+>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 31))
+
+    arguments: string; // ok
+>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 47, 29))
+}
+
+declare class StaticArgumentsFn {
+>StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 49, 1))
+
+    static arguments(): any; // ok
+>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 33))
+
+    arguments(): any; // ok
+>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 52, 28))
+}
+

From 1e5b7c5564eeae81b4ee750703cb9cd79ae8e47f Mon Sep 17 00:00:00 2001
From: Tingan Ho <tingan87@gmail.com>
Date: Sat, 21 Jan 2017 17:09:09 +0100
Subject: [PATCH 085/159] Add tests

---
 ...icPropertyNameConflictsInAmbientContext.ts | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsInAmbientContext.ts

diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsInAmbientContext.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsInAmbientContext.ts
new file mode 100644
index 00000000000..198c923b0dd
--- /dev/null
+++ b/tests/cases/conformance/classes/propertyMemberDeclarations/staticPropertyNameConflictsInAmbientContext.ts
@@ -0,0 +1,56 @@
+
+//@Filename: decl.d.ts
+// name
+declare class StaticName {
+    static name: number; // ok
+    name: string; // ok
+}
+
+declare class StaticNameFn {
+    static name(): string; // ok
+    name(): string; // ok
+}
+
+// length
+declare class StaticLength {
+    static length: number; // ok
+    length: string; // ok
+}
+
+declare class StaticLengthFn {
+    static length(): number; // ok
+    length(): number; // ok
+}
+
+// prototype
+declare class StaticPrototype {
+    static prototype: number; // ok
+    prototype: string; // ok
+}
+
+declare class StaticPrototypeFn {
+    static prototype: any; // ok
+    prototype(): any; // ok
+}
+
+// caller
+declare class StaticCaller {
+    static caller: number; // ok
+    caller: string; // ok
+}
+
+declare class StaticCallerFn {
+    static caller(): any; // ok
+    caller(): any; // ok
+}
+
+// arguments
+declare class StaticArguments {
+    static arguments: number; // ok
+    arguments: string; // ok
+}
+
+declare class StaticArgumentsFn {
+    static arguments(): any; // ok
+    arguments(): any; // ok
+}

From 36f6e19d9eeb1f7da92e466dede07f800d8c14a9 Mon Sep 17 00:00:00 2001
From: Tingan Ho <tingan87@gmail.com>
Date: Sat, 21 Jan 2017 17:09:26 +0100
Subject: [PATCH 086/159] Add reference baseline

---
 ...ropertyNameConflictsInAmbientContext.types | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types

diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types
new file mode 100644
index 00000000000..233bd8a46fc
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.types
@@ -0,0 +1,107 @@
+=== tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts ===
+
+// name
+declare class StaticName {
+>StaticName : StaticName
+
+    static name: number; // ok
+>name : number
+
+    name: string; // ok
+>name : string
+}
+
+declare class StaticNameFn {
+>StaticNameFn : StaticNameFn
+
+    static name(): string; // ok
+>name : () => string
+
+    name(): string; // ok
+>name : () => string
+}
+
+// length
+declare class StaticLength {
+>StaticLength : StaticLength
+
+    static length: number; // ok
+>length : number
+
+    length: string; // ok
+>length : string
+}
+
+declare class StaticLengthFn {
+>StaticLengthFn : StaticLengthFn
+
+    static length(): number; // ok
+>length : () => number
+
+    length(): number; // ok
+>length : () => number
+}
+
+// prototype
+declare class StaticPrototype {
+>StaticPrototype : StaticPrototype
+
+    static prototype: number; // ok
+>prototype : StaticPrototype
+
+    prototype: string; // ok
+>prototype : string
+}
+
+declare class StaticPrototypeFn {
+>StaticPrototypeFn : StaticPrototypeFn
+
+    static prototype: any; // ok
+>prototype : StaticPrototypeFn
+
+    prototype(): any; // ok
+>prototype : () => any
+}
+
+// caller
+declare class StaticCaller {
+>StaticCaller : StaticCaller
+
+    static caller: number; // ok
+>caller : number
+
+    caller: string; // ok
+>caller : string
+}
+
+declare class StaticCallerFn {
+>StaticCallerFn : StaticCallerFn
+
+    static caller(): any; // ok
+>caller : () => any
+
+    caller(): any; // ok
+>caller : () => any
+}
+
+// arguments
+declare class StaticArguments {
+>StaticArguments : StaticArguments
+
+    static arguments: number; // ok
+>arguments : number
+
+    arguments: string; // ok
+>arguments : string
+}
+
+declare class StaticArgumentsFn {
+>StaticArgumentsFn : StaticArgumentsFn
+
+    static arguments(): any; // ok
+>arguments : () => any
+
+    arguments(): any; // ok
+>arguments : () => any
+}
+

From ad71da0a7f36fafa8e940c388fd503c60ae6afee Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sat, 21 Jan 2017 13:06:54 -0800
Subject: [PATCH 087/159] Fix error reporting bug

---
 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 a5058bdf7f2..3242a30d381 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -18240,14 +18240,14 @@ namespace ts {
                 const propDeclaration = prop.valueDeclaration;
 
                 // index is numeric and property name is not valid numeric literal
-                if (indexKind === IndexKind.Number && propDeclaration && !isNumericName(propDeclaration.name)) {
+                if (indexKind === IndexKind.Number && !(propDeclaration ? isNumericName(propDeclaration.name) : isNumericLiteralName(prop.name))) {
                     return;
                 }
 
                 // perform property check if property or indexer is declared in 'type'
                 // this allows to rule out cases when both property and indexer are inherited from the base class
                 let errorNode: Node;
-                if (propDeclaration && propDeclaration.name.kind === SyntaxKind.ComputedPropertyName || prop.parent === containingType.symbol) {
+                if (propDeclaration && (propDeclaration.name.kind === SyntaxKind.ComputedPropertyName || prop.parent === containingType.symbol)) {
                     errorNode = propDeclaration;
                 }
                 else if (indexDeclaration) {

From 615784ad944a3e7ec392e6043c41028558aab5b4 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sat, 21 Jan 2017 13:07:06 -0800
Subject: [PATCH 088/159] Add tests

---
 .../interfaceExtendsObjectIntersection.ts     | 55 +++++++++++++++++++
 ...nterfaceExtendsObjectIntersectionErrors.ts | 49 +++++++++++++++++
 .../intersection/intersectionThisTypes.ts     | 40 ++++++++++++++
 3 files changed, 144 insertions(+)
 create mode 100644 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts
 create mode 100644 tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts
 create mode 100644 tests/cases/conformance/types/intersection/intersectionThisTypes.ts

diff --git a/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts b/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts
new file mode 100644
index 00000000000..003976a2b27
--- /dev/null
+++ b/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts
@@ -0,0 +1,55 @@
+// @strictNullChecks: true
+
+type T1 = { a: number };
+type T2 = T1 & { b: number };
+type T3 = () => void;
+type T4 = new () => { a: number };
+type T5 = number[];
+type T6 = [string, number];
+type T7 = { [P in 'a' | 'b' | 'c']: string };
+
+interface I1 extends T1 { x: string }
+interface I2 extends T2 { x: string }
+interface I3 extends T3 { x: string }
+interface I4 extends T4 { x: string }
+interface I5 extends T5 { x: string }
+interface I6 extends T6 { x: string }
+interface I7 extends T7 { x: string }
+
+type Constructor<T> = new () => T;
+declare function Constructor<T>(): Constructor<T>;
+
+class C1 extends Constructor<I1>() { x: string }
+class C2 extends Constructor<I2>() { x: string }
+class C3 extends Constructor<I3>() { x: string }
+class C4 extends Constructor<I4>() { x: string }
+class C5 extends Constructor<I5>() { x: string }
+class C6 extends Constructor<I6>() { x: string }
+class C7 extends Constructor<I7>() { x: string }
+
+declare function fx(x: string): string;
+declare class CX { a: number }
+declare enum EX { A, B, C }
+declare namespace NX { export const a = 1 }
+
+type T10 = typeof fx;
+type T11 = typeof CX;
+type T12 = typeof EX;
+type T13 = typeof NX;
+
+interface I10 extends T10 { x: string }
+interface I11 extends T11 { x: string }
+interface I12 extends T12 { x: string }
+interface I13 extends T13 { x: string }
+
+type Identifiable<T> = { _id: string } & T;
+
+interface I20 extends Partial<T1> { x: string }
+interface I21 extends Readonly<T1> { x: string }
+interface I22 extends Identifiable<T1> { x: string }
+interface I23 extends Identifiable<T1 & { b: number}> { x: string }
+
+class C20 extends Constructor<Partial<T1>>() { x: string }
+class C21 extends Constructor<Readonly<T1>>() { x: string }
+class C22 extends Constructor<Identifiable<T1>>() { x: string }
+class C23 extends Constructor<Identifiable<T1 & { b: number}>>() { x: string }
diff --git a/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts b/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts
new file mode 100644
index 00000000000..5a2a37fc227
--- /dev/null
+++ b/tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts
@@ -0,0 +1,49 @@
+// @strictNullChecks: true
+
+type T1 = { a: number };
+type T2 = T1 & { b: number };
+type T3 = number[];
+type T4 = [string, number];
+type T5 = { [P in 'a' | 'b' | 'c']: string };
+
+interface I1 extends T1 { a: string }
+interface I2 extends T2 { b: string }
+interface I3 extends T3 { length: string }
+interface I4 extends T4 { 0: number }
+interface I5 extends T5 { c: number }
+
+type Constructor<T> = new () => T;
+declare function Constructor<T>(): Constructor<T>;
+
+class C1 extends Constructor<T1>() { a: string }
+class C2 extends Constructor<T2>() { b: string }
+class C3 extends Constructor<T3>() { length: string }
+class C4 extends Constructor<T4>() { 0: number }
+class C5 extends Constructor<T5>() { c: number }
+
+declare class CX { static a: string }
+declare enum EX { A, B, C }
+declare namespace NX { export const a = "hello" }
+
+type TCX = typeof CX;
+type TEX = typeof EX;
+type TNX = typeof NX;
+
+interface I10 extends TCX { a: number }
+interface I11 extends TEX { C: string }
+interface I12 extends TNX { a: number }
+interface I14 extends TCX { [x: string]: number }
+interface I15 extends TEX { [x: string]: number }
+interface I16 extends TNX { [x: string]: number }
+
+type Identifiable<T> = { _id: string } & T;
+
+interface I20 extends Partial<T1> { a: string }
+interface I21 extends Readonly<T1> { a: string }
+interface I22 extends Identifiable<T1> { a: string }
+interface I23 extends Identifiable<T1 & { b: number}> { a: string }
+
+type U = { a: number } | { b: string };
+
+interface I30 extends U { x: string }
+interface I31<T> extends T { x: string }
diff --git a/tests/cases/conformance/types/intersection/intersectionThisTypes.ts b/tests/cases/conformance/types/intersection/intersectionThisTypes.ts
new file mode 100644
index 00000000000..8819148dc9e
--- /dev/null
+++ b/tests/cases/conformance/types/intersection/intersectionThisTypes.ts
@@ -0,0 +1,40 @@
+interface Thing1 {
+    a: number;
+    self(): this;
+}
+
+interface Thing2 {
+    b: number;
+    me(): this;
+}
+
+type Thing3 = Thing1 & Thing2;
+type Thing4 = Thing3 & string[];
+
+function f1(t: Thing3) {
+    t = t.self();
+    t = t.me().self().me();
+}
+
+interface Thing5 extends Thing4 {
+    c: string;
+}
+
+function f2(t: Thing5) {
+    t = t.self();
+    t = t.me().self().me();
+}
+
+interface Component {
+    extend<T>(props: T): this & T;
+}
+
+interface Label extends Component {
+    title: string;
+}
+
+function test(label: Label) {
+    const extended = label.extend({ id: 67 }).extend({ tag: "hello" });
+    extended.id;  // Ok
+    extended.tag;  // Ok
+}

From 3a34cb3088632f2361b7adafdb16fe802febcd8e Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sat, 21 Jan 2017 13:12:02 -0800
Subject: [PATCH 089/159] Accept new baselines

---
 .../interfaceExtendsObjectIntersection.js     | 145 +++++++++++
 ...interfaceExtendsObjectIntersection.symbols | 230 +++++++++++++++++
 .../interfaceExtendsObjectIntersection.types  | 242 ++++++++++++++++++
 ...ExtendsObjectIntersectionErrors.errors.txt | 197 ++++++++++++++
 ...nterfaceExtendsObjectIntersectionErrors.js |  97 +++++++
 .../reference/intersectionThisTypes.js        |  57 +++++
 .../reference/intersectionThisTypes.symbols   | 127 +++++++++
 .../reference/intersectionThisTypes.types     | 145 +++++++++++
 8 files changed, 1240 insertions(+)
 create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersection.js
 create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
 create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersection.types
 create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt
 create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js
 create mode 100644 tests/baselines/reference/intersectionThisTypes.js
 create mode 100644 tests/baselines/reference/intersectionThisTypes.symbols
 create mode 100644 tests/baselines/reference/intersectionThisTypes.types

diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.js b/tests/baselines/reference/interfaceExtendsObjectIntersection.js
new file mode 100644
index 00000000000..a6fb62f5070
--- /dev/null
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.js
@@ -0,0 +1,145 @@
+//// [interfaceExtendsObjectIntersection.ts]
+
+type T1 = { a: number };
+type T2 = T1 & { b: number };
+type T3 = () => void;
+type T4 = new () => { a: number };
+type T5 = number[];
+type T6 = [string, number];
+type T7 = { [P in 'a' | 'b' | 'c']: string };
+
+interface I1 extends T1 { x: string }
+interface I2 extends T2 { x: string }
+interface I3 extends T3 { x: string }
+interface I4 extends T4 { x: string }
+interface I5 extends T5 { x: string }
+interface I6 extends T6 { x: string }
+interface I7 extends T7 { x: string }
+
+type Constructor<T> = new () => T;
+declare function Constructor<T>(): Constructor<T>;
+
+class C1 extends Constructor<I1>() { x: string }
+class C2 extends Constructor<I2>() { x: string }
+class C3 extends Constructor<I3>() { x: string }
+class C4 extends Constructor<I4>() { x: string }
+class C5 extends Constructor<I5>() { x: string }
+class C6 extends Constructor<I6>() { x: string }
+class C7 extends Constructor<I7>() { x: string }
+
+declare function fx(x: string): string;
+declare class CX { a: number }
+declare enum EX { A, B, C }
+declare namespace NX { export const a = 1 }
+
+type T10 = typeof fx;
+type T11 = typeof CX;
+type T12 = typeof EX;
+type T13 = typeof NX;
+
+interface I10 extends T10 { x: string }
+interface I11 extends T11 { x: string }
+interface I12 extends T12 { x: string }
+interface I13 extends T13 { x: string }
+
+type Identifiable<T> = { _id: string } & T;
+
+interface I20 extends Partial<T1> { x: string }
+interface I21 extends Readonly<T1> { x: string }
+interface I22 extends Identifiable<T1> { x: string }
+interface I23 extends Identifiable<T1 & { b: number}> { x: string }
+
+class C20 extends Constructor<Partial<T1>>() { x: string }
+class C21 extends Constructor<Readonly<T1>>() { x: string }
+class C22 extends Constructor<Identifiable<T1>>() { x: string }
+class C23 extends Constructor<Identifiable<T1 & { b: number}>>() { x: string }
+
+
+//// [interfaceExtendsObjectIntersection.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var C1 = (function (_super) {
+    __extends(C1, _super);
+    function C1() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C1;
+}(Constructor()));
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C2;
+}(Constructor()));
+var C3 = (function (_super) {
+    __extends(C3, _super);
+    function C3() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C3;
+}(Constructor()));
+var C4 = (function (_super) {
+    __extends(C4, _super);
+    function C4() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C4;
+}(Constructor()));
+var C5 = (function (_super) {
+    __extends(C5, _super);
+    function C5() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C5;
+}(Constructor()));
+var C6 = (function (_super) {
+    __extends(C6, _super);
+    function C6() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C6;
+}(Constructor()));
+var C7 = (function (_super) {
+    __extends(C7, _super);
+    function C7() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C7;
+}(Constructor()));
+var C20 = (function (_super) {
+    __extends(C20, _super);
+    function C20() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C20;
+}(Constructor()));
+var C21 = (function (_super) {
+    __extends(C21, _super);
+    function C21() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C21;
+}(Constructor()));
+var C22 = (function (_super) {
+    __extends(C22, _super);
+    function C22() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C22;
+}(Constructor()));
+var C23 = (function (_super) {
+    __extends(C23, _super);
+    function C23() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C23;
+}(Constructor()));
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
new file mode 100644
index 00000000000..16c8c51cf47
--- /dev/null
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.symbols
@@ -0,0 +1,230 @@
+=== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts ===
+
+type T1 = { a: number };
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 1, 11))
+
+type T2 = T1 & { b: number };
+>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 2, 16))
+
+type T3 = () => void;
+>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29))
+
+type T4 = new () => { a: number };
+>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21))
+>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 4, 21))
+
+type T5 = number[];
+>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34))
+
+type T6 = [string, number];
+>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19))
+
+type T7 = { [P in 'a' | 'b' | 'c']: string };
+>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27))
+>P : Symbol(P, Decl(interfaceExtendsObjectIntersection.ts, 7, 13))
+
+interface I1 extends T1 { x: string }
+>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(I1.x, Decl(interfaceExtendsObjectIntersection.ts, 9, 25))
+
+interface I2 extends T2 { x: string }
+>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37))
+>T2 : Symbol(T2, Decl(interfaceExtendsObjectIntersection.ts, 1, 24))
+>x : Symbol(I2.x, Decl(interfaceExtendsObjectIntersection.ts, 10, 25))
+
+interface I3 extends T3 { x: string }
+>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37))
+>T3 : Symbol(T3, Decl(interfaceExtendsObjectIntersection.ts, 2, 29))
+>x : Symbol(I3.x, Decl(interfaceExtendsObjectIntersection.ts, 11, 25))
+
+interface I4 extends T4 { x: string }
+>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37))
+>T4 : Symbol(T4, Decl(interfaceExtendsObjectIntersection.ts, 3, 21))
+>x : Symbol(I4.x, Decl(interfaceExtendsObjectIntersection.ts, 12, 25))
+
+interface I5 extends T5 { x: string }
+>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37))
+>T5 : Symbol(T5, Decl(interfaceExtendsObjectIntersection.ts, 4, 34))
+>x : Symbol(I5.x, Decl(interfaceExtendsObjectIntersection.ts, 13, 25))
+
+interface I6 extends T6 { x: string }
+>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37))
+>T6 : Symbol(T6, Decl(interfaceExtendsObjectIntersection.ts, 5, 19))
+>x : Symbol(I6.x, Decl(interfaceExtendsObjectIntersection.ts, 14, 25))
+
+interface I7 extends T7 { x: string }
+>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37))
+>T7 : Symbol(T7, Decl(interfaceExtendsObjectIntersection.ts, 6, 27))
+>x : Symbol(I7.x, Decl(interfaceExtendsObjectIntersection.ts, 15, 25))
+
+type Constructor<T> = new () => T;
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 17, 17))
+
+declare function Constructor<T>(): Constructor<T>;
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 18, 29))
+
+class C1 extends Constructor<I1>() { x: string }
+>C1 : Symbol(C1, Decl(interfaceExtendsObjectIntersection.ts, 18, 50))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I1 : Symbol(I1, Decl(interfaceExtendsObjectIntersection.ts, 7, 45))
+>x : Symbol(C1.x, Decl(interfaceExtendsObjectIntersection.ts, 20, 36))
+
+class C2 extends Constructor<I2>() { x: string }
+>C2 : Symbol(C2, Decl(interfaceExtendsObjectIntersection.ts, 20, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I2 : Symbol(I2, Decl(interfaceExtendsObjectIntersection.ts, 9, 37))
+>x : Symbol(C2.x, Decl(interfaceExtendsObjectIntersection.ts, 21, 36))
+
+class C3 extends Constructor<I3>() { x: string }
+>C3 : Symbol(C3, Decl(interfaceExtendsObjectIntersection.ts, 21, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I3 : Symbol(I3, Decl(interfaceExtendsObjectIntersection.ts, 10, 37))
+>x : Symbol(C3.x, Decl(interfaceExtendsObjectIntersection.ts, 22, 36))
+
+class C4 extends Constructor<I4>() { x: string }
+>C4 : Symbol(C4, Decl(interfaceExtendsObjectIntersection.ts, 22, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I4 : Symbol(I4, Decl(interfaceExtendsObjectIntersection.ts, 11, 37))
+>x : Symbol(C4.x, Decl(interfaceExtendsObjectIntersection.ts, 23, 36))
+
+class C5 extends Constructor<I5>() { x: string }
+>C5 : Symbol(C5, Decl(interfaceExtendsObjectIntersection.ts, 23, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I5 : Symbol(I5, Decl(interfaceExtendsObjectIntersection.ts, 12, 37))
+>x : Symbol(C5.x, Decl(interfaceExtendsObjectIntersection.ts, 24, 36))
+
+class C6 extends Constructor<I6>() { x: string }
+>C6 : Symbol(C6, Decl(interfaceExtendsObjectIntersection.ts, 24, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I6 : Symbol(I6, Decl(interfaceExtendsObjectIntersection.ts, 13, 37))
+>x : Symbol(C6.x, Decl(interfaceExtendsObjectIntersection.ts, 25, 36))
+
+class C7 extends Constructor<I7>() { x: string }
+>C7 : Symbol(C7, Decl(interfaceExtendsObjectIntersection.ts, 25, 48))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>I7 : Symbol(I7, Decl(interfaceExtendsObjectIntersection.ts, 14, 37))
+>x : Symbol(C7.x, Decl(interfaceExtendsObjectIntersection.ts, 26, 36))
+
+declare function fx(x: string): string;
+>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48))
+>x : Symbol(x, Decl(interfaceExtendsObjectIntersection.ts, 28, 20))
+
+declare class CX { a: number }
+>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39))
+>a : Symbol(CX.a, Decl(interfaceExtendsObjectIntersection.ts, 29, 18))
+
+declare enum EX { A, B, C }
+>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30))
+>A : Symbol(EX.A, Decl(interfaceExtendsObjectIntersection.ts, 30, 17))
+>B : Symbol(EX.B, Decl(interfaceExtendsObjectIntersection.ts, 30, 20))
+>C : Symbol(EX.C, Decl(interfaceExtendsObjectIntersection.ts, 30, 23))
+
+declare namespace NX { export const a = 1 }
+>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27))
+>a : Symbol(a, Decl(interfaceExtendsObjectIntersection.ts, 31, 35))
+
+type T10 = typeof fx;
+>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43))
+>fx : Symbol(fx, Decl(interfaceExtendsObjectIntersection.ts, 26, 48))
+
+type T11 = typeof CX;
+>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21))
+>CX : Symbol(CX, Decl(interfaceExtendsObjectIntersection.ts, 28, 39))
+
+type T12 = typeof EX;
+>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21))
+>EX : Symbol(EX, Decl(interfaceExtendsObjectIntersection.ts, 29, 30))
+
+type T13 = typeof NX;
+>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21))
+>NX : Symbol(NX, Decl(interfaceExtendsObjectIntersection.ts, 30, 27))
+
+interface I10 extends T10 { x: string }
+>I10 : Symbol(I10, Decl(interfaceExtendsObjectIntersection.ts, 36, 21))
+>T10 : Symbol(T10, Decl(interfaceExtendsObjectIntersection.ts, 31, 43))
+>x : Symbol(I10.x, Decl(interfaceExtendsObjectIntersection.ts, 38, 27))
+
+interface I11 extends T11 { x: string }
+>I11 : Symbol(I11, Decl(interfaceExtendsObjectIntersection.ts, 38, 39))
+>T11 : Symbol(T11, Decl(interfaceExtendsObjectIntersection.ts, 33, 21))
+>x : Symbol(I11.x, Decl(interfaceExtendsObjectIntersection.ts, 39, 27))
+
+interface I12 extends T12 { x: string }
+>I12 : Symbol(I12, Decl(interfaceExtendsObjectIntersection.ts, 39, 39))
+>T12 : Symbol(T12, Decl(interfaceExtendsObjectIntersection.ts, 34, 21))
+>x : Symbol(I12.x, Decl(interfaceExtendsObjectIntersection.ts, 40, 27))
+
+interface I13 extends T13 { x: string }
+>I13 : Symbol(I13, Decl(interfaceExtendsObjectIntersection.ts, 40, 39))
+>T13 : Symbol(T13, Decl(interfaceExtendsObjectIntersection.ts, 35, 21))
+>x : Symbol(I13.x, Decl(interfaceExtendsObjectIntersection.ts, 41, 27))
+
+type Identifiable<T> = { _id: string } & T;
+>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18))
+>_id : Symbol(_id, Decl(interfaceExtendsObjectIntersection.ts, 43, 24))
+>T : Symbol(T, Decl(interfaceExtendsObjectIntersection.ts, 43, 18))
+
+interface I20 extends Partial<T1> { x: string }
+>I20 : Symbol(I20, Decl(interfaceExtendsObjectIntersection.ts, 43, 43))
+>Partial : Symbol(Partial, Decl(lib.d.ts, --, --))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(I20.x, Decl(interfaceExtendsObjectIntersection.ts, 45, 35))
+
+interface I21 extends Readonly<T1> { x: string }
+>I21 : Symbol(I21, Decl(interfaceExtendsObjectIntersection.ts, 45, 47))
+>Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(I21.x, Decl(interfaceExtendsObjectIntersection.ts, 46, 36))
+
+interface I22 extends Identifiable<T1> { x: string }
+>I22 : Symbol(I22, Decl(interfaceExtendsObjectIntersection.ts, 46, 48))
+>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(I22.x, Decl(interfaceExtendsObjectIntersection.ts, 47, 40))
+
+interface I23 extends Identifiable<T1 & { b: number}> { x: string }
+>I23 : Symbol(I23, Decl(interfaceExtendsObjectIntersection.ts, 47, 52))
+>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 48, 41))
+>x : Symbol(I23.x, Decl(interfaceExtendsObjectIntersection.ts, 48, 55))
+
+class C20 extends Constructor<Partial<T1>>() { x: string }
+>C20 : Symbol(C20, Decl(interfaceExtendsObjectIntersection.ts, 48, 67))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>Partial : Symbol(Partial, Decl(lib.d.ts, --, --))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(C20.x, Decl(interfaceExtendsObjectIntersection.ts, 50, 46))
+
+class C21 extends Constructor<Readonly<T1>>() { x: string }
+>C21 : Symbol(C21, Decl(interfaceExtendsObjectIntersection.ts, 50, 58))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(C21.x, Decl(interfaceExtendsObjectIntersection.ts, 51, 47))
+
+class C22 extends Constructor<Identifiable<T1>>() { x: string }
+>C22 : Symbol(C22, Decl(interfaceExtendsObjectIntersection.ts, 51, 59))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>x : Symbol(C22.x, Decl(interfaceExtendsObjectIntersection.ts, 52, 51))
+
+class C23 extends Constructor<Identifiable<T1 & { b: number}>>() { x: string }
+>C23 : Symbol(C23, Decl(interfaceExtendsObjectIntersection.ts, 52, 63))
+>Constructor : Symbol(Constructor, Decl(interfaceExtendsObjectIntersection.ts, 15, 37), Decl(interfaceExtendsObjectIntersection.ts, 17, 34))
+>Identifiable : Symbol(Identifiable, Decl(interfaceExtendsObjectIntersection.ts, 41, 39))
+>T1 : Symbol(T1, Decl(interfaceExtendsObjectIntersection.ts, 0, 0))
+>b : Symbol(b, Decl(interfaceExtendsObjectIntersection.ts, 53, 49))
+>x : Symbol(C23.x, Decl(interfaceExtendsObjectIntersection.ts, 53, 66))
+
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.types b/tests/baselines/reference/interfaceExtendsObjectIntersection.types
new file mode 100644
index 00000000000..1ff550df7b4
--- /dev/null
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.types
@@ -0,0 +1,242 @@
+=== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts ===
+
+type T1 = { a: number };
+>T1 : T1
+>a : number
+
+type T2 = T1 & { b: number };
+>T2 : T2
+>T1 : T1
+>b : number
+
+type T3 = () => void;
+>T3 : T3
+
+type T4 = new () => { a: number };
+>T4 : T4
+>a : number
+
+type T5 = number[];
+>T5 : number[]
+
+type T6 = [string, number];
+>T6 : [string, number]
+
+type T7 = { [P in 'a' | 'b' | 'c']: string };
+>T7 : T7
+>P : P
+
+interface I1 extends T1 { x: string }
+>I1 : I1
+>T1 : T1
+>x : string
+
+interface I2 extends T2 { x: string }
+>I2 : I2
+>T2 : T2
+>x : string
+
+interface I3 extends T3 { x: string }
+>I3 : I3
+>T3 : T3
+>x : string
+
+interface I4 extends T4 { x: string }
+>I4 : I4
+>T4 : T4
+>x : string
+
+interface I5 extends T5 { x: string }
+>I5 : I5
+>T5 : number[]
+>x : string
+
+interface I6 extends T6 { x: string }
+>I6 : I6
+>T6 : [string, number]
+>x : string
+
+interface I7 extends T7 { x: string }
+>I7 : I7
+>T7 : T7
+>x : string
+
+type Constructor<T> = new () => T;
+>Constructor : Constructor<T>
+>T : T
+>T : T
+
+declare function Constructor<T>(): Constructor<T>;
+>Constructor : <T>() => Constructor<T>
+>T : T
+>Constructor : Constructor<T>
+>T : T
+
+class C1 extends Constructor<I1>() { x: string }
+>C1 : C1
+>Constructor<I1>() : I1
+>Constructor : <T>() => Constructor<T>
+>I1 : I1
+>x : string
+
+class C2 extends Constructor<I2>() { x: string }
+>C2 : C2
+>Constructor<I2>() : I2
+>Constructor : <T>() => Constructor<T>
+>I2 : I2
+>x : string
+
+class C3 extends Constructor<I3>() { x: string }
+>C3 : C3
+>Constructor<I3>() : I3
+>Constructor : <T>() => Constructor<T>
+>I3 : I3
+>x : string
+
+class C4 extends Constructor<I4>() { x: string }
+>C4 : C4
+>Constructor<I4>() : I4
+>Constructor : <T>() => Constructor<T>
+>I4 : I4
+>x : string
+
+class C5 extends Constructor<I5>() { x: string }
+>C5 : C5
+>Constructor<I5>() : I5
+>Constructor : <T>() => Constructor<T>
+>I5 : I5
+>x : string
+
+class C6 extends Constructor<I6>() { x: string }
+>C6 : C6
+>Constructor<I6>() : I6
+>Constructor : <T>() => Constructor<T>
+>I6 : I6
+>x : string
+
+class C7 extends Constructor<I7>() { x: string }
+>C7 : C7
+>Constructor<I7>() : I7
+>Constructor : <T>() => Constructor<T>
+>I7 : I7
+>x : string
+
+declare function fx(x: string): string;
+>fx : (x: string) => string
+>x : string
+
+declare class CX { a: number }
+>CX : CX
+>a : number
+
+declare enum EX { A, B, C }
+>EX : EX
+>A : EX
+>B : EX
+>C : EX
+
+declare namespace NX { export const a = 1 }
+>NX : typeof NX
+>a : 1
+>1 : 1
+
+type T10 = typeof fx;
+>T10 : (x: string) => string
+>fx : (x: string) => string
+
+type T11 = typeof CX;
+>T11 : typeof CX
+>CX : typeof CX
+
+type T12 = typeof EX;
+>T12 : typeof EX
+>EX : typeof EX
+
+type T13 = typeof NX;
+>T13 : typeof NX
+>NX : typeof NX
+
+interface I10 extends T10 { x: string }
+>I10 : I10
+>T10 : (x: string) => string
+>x : string
+
+interface I11 extends T11 { x: string }
+>I11 : I11
+>T11 : typeof CX
+>x : string
+
+interface I12 extends T12 { x: string }
+>I12 : I12
+>T12 : typeof EX
+>x : string
+
+interface I13 extends T13 { x: string }
+>I13 : I13
+>T13 : typeof NX
+>x : string
+
+type Identifiable<T> = { _id: string } & T;
+>Identifiable : Identifiable<T>
+>T : T
+>_id : string
+>T : T
+
+interface I20 extends Partial<T1> { x: string }
+>I20 : I20
+>Partial : Partial<T>
+>T1 : T1
+>x : string
+
+interface I21 extends Readonly<T1> { x: string }
+>I21 : I21
+>Readonly : Readonly<T>
+>T1 : T1
+>x : string
+
+interface I22 extends Identifiable<T1> { x: string }
+>I22 : I22
+>Identifiable : Identifiable<T>
+>T1 : T1
+>x : string
+
+interface I23 extends Identifiable<T1 & { b: number}> { x: string }
+>I23 : I23
+>Identifiable : Identifiable<T>
+>T1 : T1
+>b : number
+>x : string
+
+class C20 extends Constructor<Partial<T1>>() { x: string }
+>C20 : C20
+>Constructor<Partial<T1>>() : Partial<T1>
+>Constructor : <T>() => Constructor<T>
+>Partial : Partial<T>
+>T1 : T1
+>x : string
+
+class C21 extends Constructor<Readonly<T1>>() { x: string }
+>C21 : C21
+>Constructor<Readonly<T1>>() : Readonly<T1>
+>Constructor : <T>() => Constructor<T>
+>Readonly : Readonly<T>
+>T1 : T1
+>x : string
+
+class C22 extends Constructor<Identifiable<T1>>() { x: string }
+>C22 : C22
+>Constructor<Identifiable<T1>>() : Identifiable<T1>
+>Constructor : <T>() => Constructor<T>
+>Identifiable : Identifiable<T>
+>T1 : T1
+>x : string
+
+class C23 extends Constructor<Identifiable<T1 & { b: number}>>() { x: string }
+>C23 : C23
+>Constructor<Identifiable<T1 & { b: number}>>() : Identifiable<T1 & { b: number; }>
+>Constructor : <T>() => Constructor<T>
+>Identifiable : Identifiable<T>
+>T1 : T1
+>b : number
+>x : string
+
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt
new file mode 100644
index 00000000000..839474b3bdc
--- /dev/null
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.errors.txt
@@ -0,0 +1,197 @@
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(8,11): error TS2430: Interface 'I1' incorrectly extends interface 'T1'.
+  Types of property 'a' are incompatible.
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(9,11): error TS2430: Interface 'I2' incorrectly extends interface 'T2'.
+  Type 'I2' is not assignable to type '{ b: number; }'.
+    Types of property 'b' are incompatible.
+      Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(10,11): error TS2430: Interface 'I3' incorrectly extends interface 'number[]'.
+  Types of property 'length' are incompatible.
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(11,11): error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'.
+  Types of property '0' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(12,11): error TS2430: Interface 'I5' incorrectly extends interface 'T5'.
+  Types of property 'c' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(17,7): error TS2415: Class 'C1' incorrectly extends base class 'T1'.
+  Types of property 'a' are incompatible.
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(18,7): error TS2415: Class 'C2' incorrectly extends base class 'T2'.
+  Type 'C2' is not assignable to type '{ b: number; }'.
+    Types of property 'b' are incompatible.
+      Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(19,7): error TS2415: Class 'C3' incorrectly extends base class 'number[]'.
+  Types of property 'length' are incompatible.
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(20,7): error TS2415: Class 'C4' incorrectly extends base class '[string, number]'.
+  Types of property '0' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(21,7): error TS2415: Class 'C5' incorrectly extends base class 'T5'.
+  Types of property 'c' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(31,11): error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'.
+  Types of property 'a' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(32,11): error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'.
+  Types of property 'C' are incompatible.
+    Type 'string' is not assignable to type 'EX'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(33,11): error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'.
+  Types of property 'a' are incompatible.
+    Type 'number' is not assignable to type '"hello"'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(34,29): error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(35,29): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(36,29): error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(40,11): error TS2430: Interface 'I20' incorrectly extends interface 'Partial<T1>'.
+  Types of property 'a' are incompatible.
+    Type 'string' is not assignable to type 'number | undefined'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(41,11): error TS2430: Interface 'I21' incorrectly extends interface 'Readonly<T1>'.
+  Types of property 'a' are incompatible.
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(42,11): error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable<T1>'.
+  Type 'I22' is not assignable to type 'T1'.
+    Types of property 'a' are incompatible.
+      Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(43,11): error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable<T1 & { b: number; }>'.
+  Type 'I23' is not assignable to type 'T1'.
+    Types of property 'a' are incompatible.
+      Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(47,23): error TS2312: An interface may only extend a class or another interface.
+tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts(48,26): error TS2312: An interface may only extend a class or another interface.
+
+
+==== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts (23 errors) ====
+    
+    type T1 = { a: number };
+    type T2 = T1 & { b: number };
+    type T3 = number[];
+    type T4 = [string, number];
+    type T5 = { [P in 'a' | 'b' | 'c']: string };
+    
+    interface I1 extends T1 { a: string }
+              ~~
+!!! error TS2430: Interface 'I1' incorrectly extends interface 'T1'.
+!!! error TS2430:   Types of property 'a' are incompatible.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
+    interface I2 extends T2 { b: string }
+              ~~
+!!! error TS2430: Interface 'I2' incorrectly extends interface 'T2'.
+!!! error TS2430:   Type 'I2' is not assignable to type '{ b: number; }'.
+!!! error TS2430:     Types of property 'b' are incompatible.
+!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+    interface I3 extends T3 { length: string }
+              ~~
+!!! error TS2430: Interface 'I3' incorrectly extends interface 'number[]'.
+!!! error TS2430:   Types of property 'length' are incompatible.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
+    interface I4 extends T4 { 0: number }
+              ~~
+!!! error TS2430: Interface 'I4' incorrectly extends interface '[string, number]'.
+!!! error TS2430:   Types of property '0' are incompatible.
+!!! error TS2430:     Type 'number' is not assignable to type 'string'.
+    interface I5 extends T5 { c: number }
+              ~~
+!!! error TS2430: Interface 'I5' incorrectly extends interface 'T5'.
+!!! error TS2430:   Types of property 'c' are incompatible.
+!!! error TS2430:     Type 'number' is not assignable to type 'string'.
+    
+    type Constructor<T> = new () => T;
+    declare function Constructor<T>(): Constructor<T>;
+    
+    class C1 extends Constructor<T1>() { a: string }
+          ~~
+!!! error TS2415: Class 'C1' incorrectly extends base class 'T1'.
+!!! error TS2415:   Types of property 'a' are incompatible.
+!!! error TS2415:     Type 'string' is not assignable to type 'number'.
+    class C2 extends Constructor<T2>() { b: string }
+          ~~
+!!! error TS2415: Class 'C2' incorrectly extends base class 'T2'.
+!!! error TS2415:   Type 'C2' is not assignable to type '{ b: number; }'.
+!!! error TS2415:     Types of property 'b' are incompatible.
+!!! error TS2415:       Type 'string' is not assignable to type 'number'.
+    class C3 extends Constructor<T3>() { length: string }
+          ~~
+!!! error TS2415: Class 'C3' incorrectly extends base class 'number[]'.
+!!! error TS2415:   Types of property 'length' are incompatible.
+!!! error TS2415:     Type 'string' is not assignable to type 'number'.
+    class C4 extends Constructor<T4>() { 0: number }
+          ~~
+!!! error TS2415: Class 'C4' incorrectly extends base class '[string, number]'.
+!!! error TS2415:   Types of property '0' are incompatible.
+!!! error TS2415:     Type 'number' is not assignable to type 'string'.
+    class C5 extends Constructor<T5>() { c: number }
+          ~~
+!!! error TS2415: Class 'C5' incorrectly extends base class 'T5'.
+!!! error TS2415:   Types of property 'c' are incompatible.
+!!! error TS2415:     Type 'number' is not assignable to type 'string'.
+    
+    declare class CX { static a: string }
+    declare enum EX { A, B, C }
+    declare namespace NX { export const a = "hello" }
+    
+    type TCX = typeof CX;
+    type TEX = typeof EX;
+    type TNX = typeof NX;
+    
+    interface I10 extends TCX { a: number }
+              ~~~
+!!! error TS2430: Interface 'I10' incorrectly extends interface 'typeof CX'.
+!!! error TS2430:   Types of property 'a' are incompatible.
+!!! error TS2430:     Type 'number' is not assignable to type 'string'.
+    interface I11 extends TEX { C: string }
+              ~~~
+!!! error TS2430: Interface 'I11' incorrectly extends interface 'typeof EX'.
+!!! error TS2430:   Types of property 'C' are incompatible.
+!!! error TS2430:     Type 'string' is not assignable to type 'EX'.
+    interface I12 extends TNX { a: number }
+              ~~~
+!!! error TS2430: Interface 'I12' incorrectly extends interface 'typeof NX'.
+!!! error TS2430:   Types of property 'a' are incompatible.
+!!! error TS2430:     Type 'number' is not assignable to type '"hello"'.
+    interface I14 extends TCX { [x: string]: number }
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS2411: Property 'a' of type 'string' is not assignable to string index type 'number'.
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS2411: Property 'prototype' of type 'CX' is not assignable to string index type 'number'.
+    interface I15 extends TEX { [x: string]: number }
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS2413: Numeric index type 'string' is not assignable to string index type 'number'.
+    interface I16 extends TNX { [x: string]: number }
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS2411: Property 'a' of type '"hello"' is not assignable to string index type 'number'.
+    
+    type Identifiable<T> = { _id: string } & T;
+    
+    interface I20 extends Partial<T1> { a: string }
+              ~~~
+!!! error TS2430: Interface 'I20' incorrectly extends interface 'Partial<T1>'.
+!!! error TS2430:   Types of property 'a' are incompatible.
+!!! error TS2430:     Type 'string' is not assignable to type 'number | undefined'.
+    interface I21 extends Readonly<T1> { a: string }
+              ~~~
+!!! error TS2430: Interface 'I21' incorrectly extends interface 'Readonly<T1>'.
+!!! error TS2430:   Types of property 'a' are incompatible.
+!!! error TS2430:     Type 'string' is not assignable to type 'number'.
+    interface I22 extends Identifiable<T1> { a: string }
+              ~~~
+!!! error TS2430: Interface 'I22' incorrectly extends interface 'Identifiable<T1>'.
+!!! error TS2430:   Type 'I22' is not assignable to type 'T1'.
+!!! error TS2430:     Types of property 'a' are incompatible.
+!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+    interface I23 extends Identifiable<T1 & { b: number}> { a: string }
+              ~~~
+!!! error TS2430: Interface 'I23' incorrectly extends interface 'Identifiable<T1 & { b: number; }>'.
+!!! error TS2430:   Type 'I23' is not assignable to type 'T1'.
+!!! error TS2430:     Types of property 'a' are incompatible.
+!!! error TS2430:       Type 'string' is not assignable to type 'number'.
+    
+    type U = { a: number } | { b: string };
+    
+    interface I30 extends U { x: string }
+                          ~
+!!! error TS2312: An interface may only extend a class or another interface.
+    interface I31<T> extends T { x: string }
+                             ~
+!!! error TS2312: An interface may only extend a class or another interface.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js
new file mode 100644
index 00000000000..61f84b2f7fe
--- /dev/null
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.js
@@ -0,0 +1,97 @@
+//// [interfaceExtendsObjectIntersectionErrors.ts]
+
+type T1 = { a: number };
+type T2 = T1 & { b: number };
+type T3 = number[];
+type T4 = [string, number];
+type T5 = { [P in 'a' | 'b' | 'c']: string };
+
+interface I1 extends T1 { a: string }
+interface I2 extends T2 { b: string }
+interface I3 extends T3 { length: string }
+interface I4 extends T4 { 0: number }
+interface I5 extends T5 { c: number }
+
+type Constructor<T> = new () => T;
+declare function Constructor<T>(): Constructor<T>;
+
+class C1 extends Constructor<T1>() { a: string }
+class C2 extends Constructor<T2>() { b: string }
+class C3 extends Constructor<T3>() { length: string }
+class C4 extends Constructor<T4>() { 0: number }
+class C5 extends Constructor<T5>() { c: number }
+
+declare class CX { static a: string }
+declare enum EX { A, B, C }
+declare namespace NX { export const a = "hello" }
+
+type TCX = typeof CX;
+type TEX = typeof EX;
+type TNX = typeof NX;
+
+interface I10 extends TCX { a: number }
+interface I11 extends TEX { C: string }
+interface I12 extends TNX { a: number }
+interface I14 extends TCX { [x: string]: number }
+interface I15 extends TEX { [x: string]: number }
+interface I16 extends TNX { [x: string]: number }
+
+type Identifiable<T> = { _id: string } & T;
+
+interface I20 extends Partial<T1> { a: string }
+interface I21 extends Readonly<T1> { a: string }
+interface I22 extends Identifiable<T1> { a: string }
+interface I23 extends Identifiable<T1 & { b: number}> { a: string }
+
+type U = { a: number } | { b: string };
+
+interface I30 extends U { x: string }
+interface I31<T> extends T { x: string }
+
+
+//// [interfaceExtendsObjectIntersectionErrors.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var C1 = (function (_super) {
+    __extends(C1, _super);
+    function C1() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C1;
+}(Constructor()));
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C2;
+}(Constructor()));
+var C3 = (function (_super) {
+    __extends(C3, _super);
+    function C3() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C3;
+}(Constructor()));
+var C4 = (function (_super) {
+    __extends(C4, _super);
+    function C4() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C4;
+}(Constructor()));
+var C5 = (function (_super) {
+    __extends(C5, _super);
+    function C5() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C5;
+}(Constructor()));
diff --git a/tests/baselines/reference/intersectionThisTypes.js b/tests/baselines/reference/intersectionThisTypes.js
new file mode 100644
index 00000000000..9c7be09eeb8
--- /dev/null
+++ b/tests/baselines/reference/intersectionThisTypes.js
@@ -0,0 +1,57 @@
+//// [intersectionThisTypes.ts]
+interface Thing1 {
+    a: number;
+    self(): this;
+}
+
+interface Thing2 {
+    b: number;
+    me(): this;
+}
+
+type Thing3 = Thing1 & Thing2;
+type Thing4 = Thing3 & string[];
+
+function f1(t: Thing3) {
+    t = t.self();
+    t = t.me().self().me();
+}
+
+interface Thing5 extends Thing4 {
+    c: string;
+}
+
+function f2(t: Thing5) {
+    t = t.self();
+    t = t.me().self().me();
+}
+
+interface Component {
+    extend<T>(props: T): this & T;
+}
+
+interface Label extends Component {
+    title: string;
+}
+
+function test(label: Label) {
+    const extended = label.extend({ id: 67 }).extend({ tag: "hello" });
+    extended.id;  // Ok
+    extended.tag;  // Ok
+}
+
+
+//// [intersectionThisTypes.js]
+function f1(t) {
+    t = t.self();
+    t = t.me().self().me();
+}
+function f2(t) {
+    t = t.self();
+    t = t.me().self().me();
+}
+function test(label) {
+    var extended = label.extend({ id: 67 }).extend({ tag: "hello" });
+    extended.id; // Ok
+    extended.tag; // Ok
+}
diff --git a/tests/baselines/reference/intersectionThisTypes.symbols b/tests/baselines/reference/intersectionThisTypes.symbols
new file mode 100644
index 00000000000..8a8a6cd5496
--- /dev/null
+++ b/tests/baselines/reference/intersectionThisTypes.symbols
@@ -0,0 +1,127 @@
+=== tests/cases/conformance/types/intersection/intersectionThisTypes.ts ===
+interface Thing1 {
+>Thing1 : Symbol(Thing1, Decl(intersectionThisTypes.ts, 0, 0))
+
+    a: number;
+>a : Symbol(Thing1.a, Decl(intersectionThisTypes.ts, 0, 18))
+
+    self(): this;
+>self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+}
+
+interface Thing2 {
+>Thing2 : Symbol(Thing2, Decl(intersectionThisTypes.ts, 3, 1))
+
+    b: number;
+>b : Symbol(Thing2.b, Decl(intersectionThisTypes.ts, 5, 18))
+
+    me(): this;
+>me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+}
+
+type Thing3 = Thing1 & Thing2;
+>Thing3 : Symbol(Thing3, Decl(intersectionThisTypes.ts, 8, 1))
+>Thing1 : Symbol(Thing1, Decl(intersectionThisTypes.ts, 0, 0))
+>Thing2 : Symbol(Thing2, Decl(intersectionThisTypes.ts, 3, 1))
+
+type Thing4 = Thing3 & string[];
+>Thing4 : Symbol(Thing4, Decl(intersectionThisTypes.ts, 10, 30))
+>Thing3 : Symbol(Thing3, Decl(intersectionThisTypes.ts, 8, 1))
+
+function f1(t: Thing3) {
+>f1 : Symbol(f1, Decl(intersectionThisTypes.ts, 11, 32))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 13, 12))
+>Thing3 : Symbol(Thing3, Decl(intersectionThisTypes.ts, 8, 1))
+
+    t = t.self();
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 13, 12))
+>t.self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 13, 12))
+>self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+
+    t = t.me().self().me();
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 13, 12))
+>t.me().self().me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>t.me().self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>t.me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 13, 12))
+>me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+}
+
+interface Thing5 extends Thing4 {
+>Thing5 : Symbol(Thing5, Decl(intersectionThisTypes.ts, 16, 1))
+>Thing4 : Symbol(Thing4, Decl(intersectionThisTypes.ts, 10, 30))
+
+    c: string;
+>c : Symbol(Thing5.c, Decl(intersectionThisTypes.ts, 18, 33))
+}
+
+function f2(t: Thing5) {
+>f2 : Symbol(f2, Decl(intersectionThisTypes.ts, 20, 1))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 22, 12))
+>Thing5 : Symbol(Thing5, Decl(intersectionThisTypes.ts, 16, 1))
+
+    t = t.self();
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 22, 12))
+>t.self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 22, 12))
+>self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+
+    t = t.me().self().me();
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 22, 12))
+>t.me().self().me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>t.me().self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>t.me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>t : Symbol(t, Decl(intersectionThisTypes.ts, 22, 12))
+>me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+>self : Symbol(Thing1.self, Decl(intersectionThisTypes.ts, 1, 14))
+>me : Symbol(Thing2.me, Decl(intersectionThisTypes.ts, 6, 14))
+}
+
+interface Component {
+>Component : Symbol(Component, Decl(intersectionThisTypes.ts, 25, 1))
+
+    extend<T>(props: T): this & T;
+>extend : Symbol(Component.extend, Decl(intersectionThisTypes.ts, 27, 21))
+>T : Symbol(T, Decl(intersectionThisTypes.ts, 28, 11))
+>props : Symbol(props, Decl(intersectionThisTypes.ts, 28, 14))
+>T : Symbol(T, Decl(intersectionThisTypes.ts, 28, 11))
+>T : Symbol(T, Decl(intersectionThisTypes.ts, 28, 11))
+}
+
+interface Label extends Component {
+>Label : Symbol(Label, Decl(intersectionThisTypes.ts, 29, 1))
+>Component : Symbol(Component, Decl(intersectionThisTypes.ts, 25, 1))
+
+    title: string;
+>title : Symbol(Label.title, Decl(intersectionThisTypes.ts, 31, 35))
+}
+
+function test(label: Label) {
+>test : Symbol(test, Decl(intersectionThisTypes.ts, 33, 1))
+>label : Symbol(label, Decl(intersectionThisTypes.ts, 35, 14))
+>Label : Symbol(Label, Decl(intersectionThisTypes.ts, 29, 1))
+
+    const extended = label.extend({ id: 67 }).extend({ tag: "hello" });
+>extended : Symbol(extended, Decl(intersectionThisTypes.ts, 36, 9))
+>label.extend({ id: 67 }).extend : Symbol(Component.extend, Decl(intersectionThisTypes.ts, 27, 21))
+>label.extend : Symbol(Component.extend, Decl(intersectionThisTypes.ts, 27, 21))
+>label : Symbol(label, Decl(intersectionThisTypes.ts, 35, 14))
+>extend : Symbol(Component.extend, Decl(intersectionThisTypes.ts, 27, 21))
+>id : Symbol(id, Decl(intersectionThisTypes.ts, 36, 35))
+>extend : Symbol(Component.extend, Decl(intersectionThisTypes.ts, 27, 21))
+>tag : Symbol(tag, Decl(intersectionThisTypes.ts, 36, 54))
+
+    extended.id;  // Ok
+>extended.id : Symbol(id, Decl(intersectionThisTypes.ts, 36, 35))
+>extended : Symbol(extended, Decl(intersectionThisTypes.ts, 36, 9))
+>id : Symbol(id, Decl(intersectionThisTypes.ts, 36, 35))
+
+    extended.tag;  // Ok
+>extended.tag : Symbol(tag, Decl(intersectionThisTypes.ts, 36, 54))
+>extended : Symbol(extended, Decl(intersectionThisTypes.ts, 36, 9))
+>tag : Symbol(tag, Decl(intersectionThisTypes.ts, 36, 54))
+}
+
diff --git a/tests/baselines/reference/intersectionThisTypes.types b/tests/baselines/reference/intersectionThisTypes.types
new file mode 100644
index 00000000000..285609cdfdc
--- /dev/null
+++ b/tests/baselines/reference/intersectionThisTypes.types
@@ -0,0 +1,145 @@
+=== tests/cases/conformance/types/intersection/intersectionThisTypes.ts ===
+interface Thing1 {
+>Thing1 : Thing1
+
+    a: number;
+>a : number
+
+    self(): this;
+>self : () => this
+}
+
+interface Thing2 {
+>Thing2 : Thing2
+
+    b: number;
+>b : number
+
+    me(): this;
+>me : () => this
+}
+
+type Thing3 = Thing1 & Thing2;
+>Thing3 : Thing3
+>Thing1 : Thing1
+>Thing2 : Thing2
+
+type Thing4 = Thing3 & string[];
+>Thing4 : Thing4
+>Thing3 : Thing3
+
+function f1(t: Thing3) {
+>f1 : (t: Thing3) => void
+>t : Thing3
+>Thing3 : Thing3
+
+    t = t.self();
+>t = t.self() : Thing3
+>t : Thing3
+>t.self() : Thing3
+>t.self : () => Thing3
+>t : Thing3
+>self : () => Thing3
+
+    t = t.me().self().me();
+>t = t.me().self().me() : Thing3
+>t : Thing3
+>t.me().self().me() : Thing3
+>t.me().self().me : () => Thing3
+>t.me().self() : Thing3
+>t.me().self : () => Thing3
+>t.me() : Thing3
+>t.me : () => Thing3
+>t : Thing3
+>me : () => Thing3
+>self : () => Thing3
+>me : () => Thing3
+}
+
+interface Thing5 extends Thing4 {
+>Thing5 : Thing5
+>Thing4 : Thing4
+
+    c: string;
+>c : string
+}
+
+function f2(t: Thing5) {
+>f2 : (t: Thing5) => void
+>t : Thing5
+>Thing5 : Thing5
+
+    t = t.self();
+>t = t.self() : Thing5
+>t : Thing5
+>t.self() : Thing5
+>t.self : () => Thing5
+>t : Thing5
+>self : () => Thing5
+
+    t = t.me().self().me();
+>t = t.me().self().me() : Thing5
+>t : Thing5
+>t.me().self().me() : Thing5
+>t.me().self().me : () => Thing5
+>t.me().self() : Thing5
+>t.me().self : () => Thing5
+>t.me() : Thing5
+>t.me : () => Thing5
+>t : Thing5
+>me : () => Thing5
+>self : () => Thing5
+>me : () => Thing5
+}
+
+interface Component {
+>Component : Component
+
+    extend<T>(props: T): this & T;
+>extend : <T>(props: T) => this & T
+>T : T
+>props : T
+>T : T
+>T : T
+}
+
+interface Label extends Component {
+>Label : Label
+>Component : Component
+
+    title: string;
+>title : string
+}
+
+function test(label: Label) {
+>test : (label: Label) => void
+>label : Label
+>Label : Label
+
+    const extended = label.extend({ id: 67 }).extend({ tag: "hello" });
+>extended : Label & { id: number; } & { tag: string; }
+>label.extend({ id: 67 }).extend({ tag: "hello" }) : Label & { id: number; } & { tag: string; }
+>label.extend({ id: 67 }).extend : <T>(props: T) => Label & { id: number; } & T
+>label.extend({ id: 67 }) : Label & { id: number; }
+>label.extend : <T>(props: T) => Label & T
+>label : Label
+>extend : <T>(props: T) => Label & T
+>{ id: 67 } : { id: number; }
+>id : number
+>67 : 67
+>extend : <T>(props: T) => Label & { id: number; } & T
+>{ tag: "hello" } : { tag: string; }
+>tag : string
+>"hello" : "hello"
+
+    extended.id;  // Ok
+>extended.id : number
+>extended : Label & { id: number; } & { tag: string; }
+>id : number
+
+    extended.tag;  // Ok
+>extended.tag : string
+>extended : Label & { id: number; } & { tag: string; }
+>tag : string
+}
+

From 80e5f2f314b46e327567902a912b2d885e6a4e63 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 22 Jan 2017 11:53:18 -0800
Subject: [PATCH 090/159] Add regression test

---
 .../conformance/types/keyof/keyofAndIndexedAccess.ts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
index a4088e65df4..04c26fbe8f7 100644
--- a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
+++ b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
@@ -505,3 +505,15 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
 // Repro from #13514
 
 declare function head<T extends Array<any>>(list: T): T[0];
+
+// Repro from #13604
+
+class A<T> {
+	props: T & { foo: string };
+}
+
+class B extends A<{ x: number}> {
+	f(p: this["props"]) {
+		p.x;
+	}
+}

From 6d6b19fd23e7795da5e73c4fe72517d898536b22 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 22 Jan 2017 11:54:39 -0800
Subject: [PATCH 091/159] Fix typo in intersection apparent type

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 60d109d7600..bd8ff7568f3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4871,7 +4871,7 @@ namespace ts {
          */
         function getApparentType(type: Type): Type {
             const t = type.flags & TypeFlags.TypeVariable ? getBaseConstraintOfType(<TypeVariable>type) || emptyObjectType : type;
-            return t.flags & TypeFlags.Intersection ? getApparentTypeOfIntersectionType(<IntersectionType>type) :
+            return t.flags & TypeFlags.Intersection ? getApparentTypeOfIntersectionType(<IntersectionType>t) :
                 t.flags & TypeFlags.StringLike ? globalStringType :
                 t.flags & TypeFlags.NumberLike ? globalNumberType :
                 t.flags & TypeFlags.BooleanLike ? globalBooleanType :

From f0e90c0d8bcc0009dca5e4ffcbcbb9b529779f03 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 22 Jan 2017 11:59:40 -0800
Subject: [PATCH 092/159] Accept new baselines

---
 .../reference/keyofAndIndexedAccess.js        | 38 +++++++++++++++++++
 .../reference/keyofAndIndexedAccess.symbols   | 28 ++++++++++++++
 .../reference/keyofAndIndexedAccess.types     | 28 ++++++++++++++
 3 files changed, 94 insertions(+)

diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js
index a86184c8ff0..e7df8bbd5a1 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.js
+++ b/tests/baselines/reference/keyofAndIndexedAccess.js
@@ -504,6 +504,18 @@ function updateIds2<T extends { [x: string]: string }, K extends keyof T>(
 // Repro from #13514
 
 declare function head<T extends Array<any>>(list: T): T[0];
+
+// Repro from #13604
+
+class A<T> {
+	props: T & { foo: string };
+}
+
+class B extends A<{ x: number}> {
+	f(p: this["props"]) {
+		p.x;
+	}
+}
 
 
 //// [keyofAndIndexedAccess.js]
@@ -834,6 +846,22 @@ function updateIds2(obj, key, stringMap) {
     var x = obj[key];
     stringMap[x]; // Should be OK.
 }
+// Repro from #13604
+var A = (function () {
+    function A() {
+    }
+    return A;
+}());
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    B.prototype.f = function (p) {
+        p.x;
+    };
+    return B;
+}(A));
 
 
 //// [keyofAndIndexedAccess.d.ts]
@@ -1066,3 +1094,13 @@ declare function updateIds2<T extends {
     [oldId: string]: string;
 }): void;
 declare function head<T extends Array<any>>(list: T): T[0];
+declare class A<T> {
+    props: T & {
+        foo: string;
+    };
+}
+declare class B extends A<{
+    x: number;
+}> {
+    f(p: this["props"]): void;
+}
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index 4c12c6554c9..01501cd719c 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -1816,3 +1816,31 @@ declare function head<T extends Array<any>>(list: T): T[0];
 >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22))
 >T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 504, 22))
 
+// Repro from #13604
+
+class A<T> {
+>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8))
+
+	props: T & { foo: string };
+>props : Symbol(A.props, Decl(keyofAndIndexedAccess.ts, 508, 12))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 508, 8))
+>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 509, 13))
+}
+
+class B extends A<{ x: number}> {
+>B : Symbol(B, Decl(keyofAndIndexedAccess.ts, 510, 1))
+>A : Symbol(A, Decl(keyofAndIndexedAccess.ts, 504, 59))
+>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19))
+
+	f(p: this["props"]) {
+>f : Symbol(B.f, Decl(keyofAndIndexedAccess.ts, 512, 33))
+>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3))
+
+		p.x;
+>p.x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19))
+>p : Symbol(p, Decl(keyofAndIndexedAccess.ts, 513, 3))
+>x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 512, 19))
+	}
+}
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index 3919d768151..21c9d645ce4 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -2138,3 +2138,31 @@ declare function head<T extends Array<any>>(list: T): T[0];
 >T : T
 >T : T
 
+// Repro from #13604
+
+class A<T> {
+>A : A<T>
+>T : T
+
+	props: T & { foo: string };
+>props : T & { foo: string; }
+>T : T
+>foo : string
+}
+
+class B extends A<{ x: number}> {
+>B : B
+>A : A<{ x: number; }>
+>x : number
+
+	f(p: this["props"]) {
+>f : (p: this["props"]) => void
+>p : this["props"]
+
+		p.x;
+>p.x : number
+>p : this["props"]
+>x : number
+	}
+}
+

From dd0ed44b9aaa7dcd24bb415a5a6a241cd2d6061f Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Mon, 23 Jan 2017 17:40:20 +0100
Subject: [PATCH 093/159] Add option to output .js files while preserving jsx

This commit adds the ability to preserve jsx in source code, but
also to output .js files rather than .jsx files. This is useful
for react-native which does not support .jsx files.
---
 lib/protocol.d.ts                             |  5 +-
 src/compiler/commandLineParser.ts             |  3 +-
 src/compiler/diagnosticMessages.json          |  2 +-
 src/compiler/types.ts                         |  3 +-
 src/harness/unittests/commandLineParsing.ts   |  2 +-
 .../convertCompilerOptionsFromJson.ts         |  2 +-
 src/harness/unittests/matchFiles.ts           | 54 ++++++++++++++++-
 src/server/protocol.ts                        |  9 +--
 tests/cases/unittests/matchFiles.ts           | 58 ++++++++++++++++++-
 9 files changed, 125 insertions(+), 13 deletions(-)

diff --git a/lib/protocol.d.ts b/lib/protocol.d.ts
index d6c0246af34..66c2ef5c8db 100644
--- a/lib/protocol.d.ts
+++ b/lib/protocol.d.ts
@@ -1798,9 +1798,10 @@ declare namespace ts.server.protocol {
     namespace JsxEmit {
         type None = "None";
         type Preserve = "Preserve";
+        type PreserveWithJsExtension = "PreserveWithJsExtension";
         type React = "React";
     }
-    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
+    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.PreserveWithJsExtension;
     namespace ModuleKind {
         type None = "None";
         type CommonJS = "CommonJS";
@@ -1880,4 +1881,4 @@ declare namespace ts {
 }
 import protocol = ts.server.protocol;
 export = protocol;
-export as namespace protocol;
\ No newline at end of file
+export as namespace protocol;
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index b222df53630..7c69676d6f0 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -67,10 +67,11 @@ namespace ts {
             name: "jsx",
             type: createMapFromTemplate({
                 "preserve": JsxEmit.Preserve,
+                "preservewithjsextension": JsxEmit.PreserveWithJsExtension,
                 "react": JsxEmit.React
             }),
             paramType: Diagnostics.KIND,
-            description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_or_react,
+            description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_preserveWithJsExtension_or_react,
         },
         {
             name: "reactNamespace",
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 43bb7415c88..6646017e73d 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2713,7 +2713,7 @@
         "category": "Message",
         "code": 6079
     },
-    "Specify JSX code generation: 'preserve' or 'react'": {
+    "Specify JSX code generation: 'preserve', 'preserveWithJsExtension', or 'react'": {
         "category": "Message",
         "code": 6080
     },
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index c16c199d3eb..9024b7c1b13 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3298,7 +3298,8 @@
     export const enum JsxEmit {
         None = 0,
         Preserve = 1,
-        React = 2
+        React = 2,
+        PreserveWithJsExtension = 3
     }
 
     export const enum NewLineKind {
diff --git a/src/harness/unittests/commandLineParsing.ts b/src/harness/unittests/commandLineParsing.ts
index 8c691992043..34a096628f9 100644
--- a/src/harness/unittests/commandLineParsing.ts
+++ b/src/harness/unittests/commandLineParsing.ts
@@ -87,7 +87,7 @@ namespace ts {
                         start: undefined,
                         length: undefined,
                     }, {
-                            messageText: "Argument for '--jsx' option must be: 'preserve', 'react'",
+                            messageText: "Argument for '--jsx' option must be: 'preserve', 'preservewithjsextension', 'react'",
                             category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                             code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
diff --git a/src/harness/unittests/convertCompilerOptionsFromJson.ts b/src/harness/unittests/convertCompilerOptionsFromJson.ts
index f44dc259710..cbfa47180f3 100644
--- a/src/harness/unittests/convertCompilerOptionsFromJson.ts
+++ b/src/harness/unittests/convertCompilerOptionsFromJson.ts
@@ -94,7 +94,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--jsx' option must be: 'preserve', 'react'",
+                        messageText: "Argument for '--jsx' option must be: 'preserve', 'preservewithjsextension', 'react'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
diff --git a/src/harness/unittests/matchFiles.ts b/src/harness/unittests/matchFiles.ts
index c562fcefe91..2b4bbfd4ee6 100644
--- a/src/harness/unittests/matchFiles.ts
+++ b/src/harness/unittests/matchFiles.ts
@@ -909,6 +909,31 @@ namespace ts {
                 const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
                 assertParsed(actual, expected);
             });
+            it("with jsx=preserveWithJsExtension, allowJs=false", () => {
+                const json = {
+                    compilerOptions: {
+                        jsx: "preserveWithJsExtension",
+                        allowJs: false
+                    }
+                };
+                const expected: ts.ParsedCommandLine = {
+                    options: {
+                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        allowJs: false
+                    },
+                    errors: [],
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assertParsed(actual, expected);
+            });
             it("with jsx=none, allowJs=true", () => {
                 const json = {
                     compilerOptions: {
@@ -961,6 +986,33 @@ namespace ts {
                 const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
                 assertParsed(actual, expected);
             });
+            it("with jsx=preserveWithJsExtension, allowJs=true", () => {
+                const json = {
+                    compilerOptions: {
+                        jsx: "preserveWithJsExtension",
+                        allowJs: true
+                    }
+                };
+                const expected: ts.ParsedCommandLine = {
+                    options: {
+                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        allowJs: true
+                    },
+                    errors: [],
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                        "c:/dev/d.js",
+                        "c:/dev/e.jsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assertParsed(actual, expected);
+            });
             it("exclude .min.js files using wildcards", () => {
                 const json = {
                     compilerOptions: {
@@ -1306,4 +1358,4 @@ namespace ts {
             });
         });
     });
-}
\ No newline at end of file
+}
diff --git a/src/server/protocol.ts b/src/server/protocol.ts
index 680b81dff99..b18c887126b 100644
--- a/src/server/protocol.ts
+++ b/src/server/protocol.ts
@@ -417,7 +417,7 @@ namespace ts.server.protocol {
         startOffset: number;
 
         /**
-         * Position (can be specified instead of line/offset pair) 
+         * Position (can be specified instead of line/offset pair)
          */
         /* @internal */
         startPosition?: number;
@@ -433,7 +433,7 @@ namespace ts.server.protocol {
         endOffset: number;
 
         /**
-         * Position (can be specified instead of line/offset pair) 
+         * Position (can be specified instead of line/offset pair)
          */
         /* @internal */
         endPosition?: number;
@@ -445,7 +445,7 @@ namespace ts.server.protocol {
     }
 
     /**
-     * Response for GetCodeFixes request. 
+     * Response for GetCodeFixes request.
      */
     export interface GetCodeFixesResponse extends Response {
         body?: CodeAction[];
@@ -2272,10 +2272,11 @@ namespace ts.server.protocol {
     export namespace JsxEmit {
         export type None = "None";
         export type Preserve = "Preserve";
+        export type PreserveWithJsExtension = "PreserveWithJsExtension";
         export type React = "React";
     }
 
-    export type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
+    export type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.PreserveWithJsExtension;
 
     export namespace ModuleKind {
         export type None = "None";
diff --git a/tests/cases/unittests/matchFiles.ts b/tests/cases/unittests/matchFiles.ts
index 91be2de8747..ef982f5f2bb 100644
--- a/tests/cases/unittests/matchFiles.ts
+++ b/tests/cases/unittests/matchFiles.ts
@@ -898,6 +898,33 @@ namespace ts {
                 assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
                 assert.deepEqual(actual.errors, expected.errors);
             });
+            it("with jsx=preserveWithJsExtension, allowJs=false", () => {
+                const json = {
+                    compilerOptions: {
+                        jsx: "preserveWithJsExtension",
+                        allowJs: false
+                    }
+                };
+                const expected: ts.ParsedCommandLine = {
+                    options: {
+                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        allowJs: false
+                    },
+                    errors: [],
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+                assert.deepEqual(actual.errors, expected.errors);
+            });
             it("with jsx=none, allowJs=true", () => {
                 const json = {
                     compilerOptions: {
@@ -954,6 +981,35 @@ namespace ts {
                 assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
                 assert.deepEqual(actual.errors, expected.errors);
             });
+            it("with jsx=preserveWithJsExtension, allowJs=true", () => {
+                const json = {
+                    compilerOptions: {
+                        jsx: "preserveWithJsExtension",
+                        allowJs: true
+                    }
+                };
+                const expected: ts.ParsedCommandLine = {
+                    options: {
+                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        allowJs: true
+                    },
+                    errors: [],
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                        "c:/dev/d.js",
+                        "c:/dev/e.jsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+                assert.deepEqual(actual.errors, expected.errors);
+            });
             describe("with trailing recursive directory", () => {
                 it("in includes", () => {
                     const json = {
@@ -1149,4 +1205,4 @@ namespace ts {
             });
         });
     });
-}
\ No newline at end of file
+}

From 7879b22ea9b210934c50b8d87df418379dfcc435 Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Mon, 23 Jan 2017 19:30:24 +0100
Subject: [PATCH 094/159] Add test case for preserveWithJsExtension

---
 ...utTsxFile_PreserveWithJsExtension.baseline | 26 +++++++++++++++++++
 ...itOutputTsxFile_PreserveWithJsExtension.ts | 22 ++++++++++++++++
 2 files changed, 48 insertions(+)
 create mode 100644 tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline
 create mode 100644 tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts

diff --git a/tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline b/tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline
new file mode 100644
index 00000000000..88fb0f0daf6
--- /dev/null
+++ b/tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline
@@ -0,0 +1,26 @@
+EmitSkipped: false
+FileName : /tests/cases/fourslash/inputFile1.js.map
+{"version":3,"file":"inputFile1.js","sourceRoot":"","sources":["inputFile1.ts"],"names":[],"mappings":"AAAA,kBAAkB;AACjB,IAAI,CAAC,GAAW,CAAC,CAAC;AAClB;IAAA;IAGA,CAAC;IAAD,UAAC;AAAD,CAAC,AAHD,IAGC"}FileName : /tests/cases/fourslash/inputFile1.js
+// regular ts file
+var t = 5;
+var Bar = (function () {
+    function Bar() {
+    }
+    return Bar;
+}());
+//# sourceMappingURL=inputFile1.js.mapFileName : /tests/cases/fourslash/inputFile1.d.ts
+declare var t: number;
+declare class Bar {
+    x: string;
+    y: number;
+}
+
+EmitSkipped: false
+FileName : /tests/cases/fourslash/inputFile2.js.map
+{"version":3,"file":"inputFile2.js","sourceRoot":"","sources":["inputFile2.tsx"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,QAAQ,CAAC;AACjB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,CAAC,CAAC,EAAG,CAAA"}FileName : /tests/cases/fourslash/inputFile2.js
+var y = "my div";
+var x = <div name={y}/>;
+//# sourceMappingURL=inputFile2.js.mapFileName : /tests/cases/fourslash/inputFile2.d.ts
+declare var y: string;
+declare var x: any;
+
diff --git a/tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts b/tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts
new file mode 100644
index 00000000000..a1e4ce2d984
--- /dev/null
+++ b/tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts
@@ -0,0 +1,22 @@
+/// <reference path="fourslash.ts" />
+
+// @BaselineFile: getEmitOutputTsxFile_PreserveWithJsExtension.baseline
+// @declaration: true
+// @sourceMap: true
+// @jsx: preserveWithJsExtension
+
+// @Filename: inputFile1.ts
+// @emitThisFile: true
+////// regular ts file
+//// var t: number = 5;
+//// class Bar {
+////    x : string;
+////    y : number
+//// }
+
+// @Filename: inputFile2.tsx
+// @emitThisFile: true
+//// var y = "my div";
+//// var x = <div name= {y} />
+
+verify.baselineGetEmitOutput();

From a32914f6872b9c5764d77f77ea85c7160ff9ae28 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 23 Jan 2017 11:14:29 -0800
Subject: [PATCH 095/159] Combine `forEachExpectedEmitFile` and
 `forEachEmittedFile`

---
 src/compiler/declarationEmitter.ts |  4 ++--
 src/compiler/emitter.ts            |  2 +-
 src/compiler/program.ts            |  2 +-
 src/compiler/utilities.ts          | 24 ++++++++----------------
 4 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 2287de179e3..46df4fed689 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -32,7 +32,7 @@ namespace ts {
 
     export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
         const declarationDiagnostics = createDiagnosticCollection();
-        forEachExpectedEmitFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
+        forEachEmittedFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
         return declarationDiagnostics.getDiagnostics(targetSourceFile ? targetSourceFile.fileName : undefined);
 
         function getDeclarationDiagnosticsFromFile({ declarationFilePath }: EmitFileNames, sources: SourceFile[], isBundledEmit: boolean) {
@@ -1788,7 +1788,7 @@ namespace ts {
             }
             else {
                 // Get the declaration file path
-                forEachExpectedEmitFile(host, getDeclFileName, referencedFile, emitOnlyDtsFiles);
+                forEachEmittedFile(host, getDeclFileName, referencedFile, emitOnlyDtsFiles);
             }
 
             if (declFileName) {
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 1c4662fa587..cc006a06637 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -73,7 +73,7 @@ namespace ts {
 
         // Emit each output file
         performance.mark("beforePrint");
-        forEachEmittedFile(host, transformed, emitFile, emitOnlyDtsFiles);
+        forEachEmittedFile(host, emitFile, transformed, emitOnlyDtsFiles);
         performance.measure("printTime", "beforePrint");
 
         // Clean up emit nodes on parse tree
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 851e206d448..650711afc79 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -1707,7 +1707,7 @@ namespace ts {
             if (!options.noEmit && !options.suppressOutputPathCheck) {
                 const emitHost = getEmitHost();
                 const emitFilesSeen = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
-                forEachExpectedEmitFile(emitHost, (emitFileNames) => {
+                forEachEmittedFile(emitHost, (emitFileNames) => {
                     verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
                     verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);
                 });
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index f59d384e490..b7cc0f0de6d 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2590,27 +2590,20 @@ namespace ts {
     }
 
     /**
-     * Iterates over the source files that are expected to have an emit output. This function
-     * is used by the legacy emitter and the declaration emitter and should not be used by
-     * the tree transforming emitter.
+     * Iterates over the source files that are expected to have an emit output.
      *
      * @param host An EmitHost.
      * @param action The action to execute.
-     * @param targetSourceFile An optional target source file to emit.
+     * @param sourceFilesOrTargetSourceFile
+     *   If an array, the full list of source files to emit.
+     *   Else, calls `getSourceFilesToEmit` with the (optional) target source file to determine the list of source files to emit.
      */
-    export function forEachExpectedEmitFile(host: EmitHost,
-        action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
-        targetSourceFile?: SourceFile,
+    export function forEachEmittedFile(
+        host: EmitHost, action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
+        sourceFilesOrTargetSourceFile?: SourceFile[] | SourceFile,
         emitOnlyDtsFiles?: boolean) {
-        forEachEmittedFile(host, getSourceFilesToEmit(host, targetSourceFile), action, emitOnlyDtsFiles);
-    }
 
-    /**
-     * Iterates over each source file to emit.
-     */
-    export function forEachEmittedFile(host: EmitHost, sourceFiles: SourceFile[],
-        action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
-        emitOnlyDtsFiles?: boolean) {
+        const sourceFiles = isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile);
         const options = host.getCompilerOptions();
         if (options.outFile || options.out) {
             if (sourceFiles.length) {
@@ -2622,7 +2615,6 @@ namespace ts {
         }
         else {
             for (const sourceFile of sourceFiles) {
-                const options = host.getCompilerOptions();
                 const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, getOutputExtension(sourceFile, options));
                 const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
                 const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (emitOnlyDtsFiles || options.declaration) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;

From 8d590d51916e6491191634097b8fb04f40d7d964 Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Mon, 23 Jan 2017 21:42:39 +0100
Subject: [PATCH 096/159] rename preserveWithJsExtension to react-native

---
 lib/protocol.d.ts                                    |  4 ++--
 src/compiler/commandLineParser.ts                    |  4 ++--
 src/compiler/diagnosticMessages.json                 |  2 +-
 src/compiler/types.ts                                |  2 +-
 src/harness/unittests/commandLineParsing.ts          |  2 +-
 .../unittests/convertCompilerOptionsFromJson.ts      |  2 +-
 src/harness/unittests/matchFiles.ts                  | 12 ++++++------
 src/server/protocol.ts                               |  4 ++--
 ...ine => getEmitOutputTsxFile_ReactNative.baseline} |  0
 ...ension.ts => getEmitOutputTsxFile_ReactNative.ts} |  4 ++--
 tests/cases/unittests/matchFiles.ts                  | 12 ++++++------
 11 files changed, 24 insertions(+), 24 deletions(-)
 rename tests/baselines/reference/{getEmitOutputTsxFile_PreserveWithJsExtension.baseline => getEmitOutputTsxFile_ReactNative.baseline} (100%)
 rename tests/cases/fourslash/{getEmitOutputTsxFile_PreserveWithJsExtension.ts => getEmitOutputTsxFile_ReactNative.ts} (75%)

diff --git a/lib/protocol.d.ts b/lib/protocol.d.ts
index 66c2ef5c8db..cd46ebcd366 100644
--- a/lib/protocol.d.ts
+++ b/lib/protocol.d.ts
@@ -1798,10 +1798,10 @@ declare namespace ts.server.protocol {
     namespace JsxEmit {
         type None = "None";
         type Preserve = "Preserve";
-        type PreserveWithJsExtension = "PreserveWithJsExtension";
+        type ReactNative = "ReactNative";
         type React = "React";
     }
-    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.PreserveWithJsExtension;
+    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.ReactNative;
     namespace ModuleKind {
         type None = "None";
         type CommonJS = "CommonJS";
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 7c69676d6f0..248726693c9 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -67,11 +67,11 @@ namespace ts {
             name: "jsx",
             type: createMapFromTemplate({
                 "preserve": JsxEmit.Preserve,
-                "preservewithjsextension": JsxEmit.PreserveWithJsExtension,
+                "react-native": JsxEmit.ReactNative,
                 "react": JsxEmit.React
             }),
             paramType: Diagnostics.KIND,
-            description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_preserveWithJsExtension_or_react,
+            description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_react_native_or_react,
         },
         {
             name: "reactNamespace",
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 6646017e73d..4278784e9ab 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2713,7 +2713,7 @@
         "category": "Message",
         "code": 6079
     },
-    "Specify JSX code generation: 'preserve', 'preserveWithJsExtension', or 'react'": {
+    "Specify JSX code generation: 'preserve', 'react-native', or 'react'": {
         "category": "Message",
         "code": 6080
     },
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 9024b7c1b13..6ac7d573eda 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3299,7 +3299,7 @@
         None = 0,
         Preserve = 1,
         React = 2,
-        PreserveWithJsExtension = 3
+        ReactNative = 3
     }
 
     export const enum NewLineKind {
diff --git a/src/harness/unittests/commandLineParsing.ts b/src/harness/unittests/commandLineParsing.ts
index 34a096628f9..1895fe2d60e 100644
--- a/src/harness/unittests/commandLineParsing.ts
+++ b/src/harness/unittests/commandLineParsing.ts
@@ -87,7 +87,7 @@ namespace ts {
                         start: undefined,
                         length: undefined,
                     }, {
-                            messageText: "Argument for '--jsx' option must be: 'preserve', 'preservewithjsextension', 'react'",
+                            messageText: "Argument for '--jsx' option must be: 'preserve', 'react-native', 'react'",
                             category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                             code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
diff --git a/src/harness/unittests/convertCompilerOptionsFromJson.ts b/src/harness/unittests/convertCompilerOptionsFromJson.ts
index cbfa47180f3..4e442173883 100644
--- a/src/harness/unittests/convertCompilerOptionsFromJson.ts
+++ b/src/harness/unittests/convertCompilerOptionsFromJson.ts
@@ -94,7 +94,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--jsx' option must be: 'preserve', 'preservewithjsextension', 'react'",
+                        messageText: "Argument for '--jsx' option must be: 'preserve', 'react-native', 'react'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
diff --git a/src/harness/unittests/matchFiles.ts b/src/harness/unittests/matchFiles.ts
index 2b4bbfd4ee6..38e5c6c4393 100644
--- a/src/harness/unittests/matchFiles.ts
+++ b/src/harness/unittests/matchFiles.ts
@@ -909,16 +909,16 @@ namespace ts {
                 const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
                 assertParsed(actual, expected);
             });
-            it("with jsx=preserveWithJsExtension, allowJs=false", () => {
+            it("with jsx=react-native, allowJs=false", () => {
                 const json = {
                     compilerOptions: {
-                        jsx: "preserveWithJsExtension",
+                        jsx: "react-native",
                         allowJs: false
                     }
                 };
                 const expected: ts.ParsedCommandLine = {
                     options: {
-                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        jsx: ts.JsxEmit.ReactNative,
                         allowJs: false
                     },
                     errors: [],
@@ -986,16 +986,16 @@ namespace ts {
                 const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
                 assertParsed(actual, expected);
             });
-            it("with jsx=preserveWithJsExtension, allowJs=true", () => {
+            it("with jsx=react-native, allowJs=true", () => {
                 const json = {
                     compilerOptions: {
-                        jsx: "preserveWithJsExtension",
+                        jsx: "react-native",
                         allowJs: true
                     }
                 };
                 const expected: ts.ParsedCommandLine = {
                     options: {
-                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        jsx: ts.JsxEmit.ReactNative,
                         allowJs: true
                     },
                     errors: [],
diff --git a/src/server/protocol.ts b/src/server/protocol.ts
index b18c887126b..e3fe17362d7 100644
--- a/src/server/protocol.ts
+++ b/src/server/protocol.ts
@@ -2272,11 +2272,11 @@ namespace ts.server.protocol {
     export namespace JsxEmit {
         export type None = "None";
         export type Preserve = "Preserve";
-        export type PreserveWithJsExtension = "PreserveWithJsExtension";
+        export type ReactNative = "ReactNative";
         export type React = "React";
     }
 
-    export type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.PreserveWithJsExtension;
+    export type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.ReactNative;
 
     export namespace ModuleKind {
         export type None = "None";
diff --git a/tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline b/tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline
similarity index 100%
rename from tests/baselines/reference/getEmitOutputTsxFile_PreserveWithJsExtension.baseline
rename to tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline
diff --git a/tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts b/tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts
similarity index 75%
rename from tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts
rename to tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts
index a1e4ce2d984..c2aac0e9d03 100644
--- a/tests/cases/fourslash/getEmitOutputTsxFile_PreserveWithJsExtension.ts
+++ b/tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts
@@ -1,9 +1,9 @@
 /// <reference path="fourslash.ts" />
 
-// @BaselineFile: getEmitOutputTsxFile_PreserveWithJsExtension.baseline
+// @BaselineFile: getEmitOutputTsxFile_ReactNative.baseline
 // @declaration: true
 // @sourceMap: true
-// @jsx: preserveWithJsExtension
+// @jsx: react-native
 
 // @Filename: inputFile1.ts
 // @emitThisFile: true
diff --git a/tests/cases/unittests/matchFiles.ts b/tests/cases/unittests/matchFiles.ts
index ef982f5f2bb..e3448136c08 100644
--- a/tests/cases/unittests/matchFiles.ts
+++ b/tests/cases/unittests/matchFiles.ts
@@ -898,16 +898,16 @@ namespace ts {
                 assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
                 assert.deepEqual(actual.errors, expected.errors);
             });
-            it("with jsx=preserveWithJsExtension, allowJs=false", () => {
+            it("with jsx=react-native, allowJs=false", () => {
                 const json = {
                     compilerOptions: {
-                        jsx: "preserveWithJsExtension",
+                        jsx: "react-native",
                         allowJs: false
                     }
                 };
                 const expected: ts.ParsedCommandLine = {
                     options: {
-                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        jsx: ts.JsxEmit.ReactNative,
                         allowJs: false
                     },
                     errors: [],
@@ -981,16 +981,16 @@ namespace ts {
                 assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
                 assert.deepEqual(actual.errors, expected.errors);
             });
-            it("with jsx=preserveWithJsExtension, allowJs=true", () => {
+            it("with jsx=react-native, allowJs=true", () => {
                 const json = {
                     compilerOptions: {
-                        jsx: "preserveWithJsExtension",
+                        jsx: "react-native",
                         allowJs: true
                     }
                 };
                 const expected: ts.ParsedCommandLine = {
                     options: {
-                        jsx: ts.JsxEmit.PreserveWithJsExtension,
+                        jsx: ts.JsxEmit.ReactNative,
                         allowJs: true
                     },
                     errors: [],

From 7bf52ee1fde05154eb38042e63ac1ef95d0a415d Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Mon, 23 Jan 2017 22:08:39 +0100
Subject: [PATCH 097/159] add notifications and tests for jsx react-native es3

---
 src/compiler/transformers/es5.ts                    |  4 ++--
 tests/baselines/reference/es3-jsx-preserve.js       | 11 +++++++++++
 tests/baselines/reference/es3-jsx-preserve.symbols  | 11 +++++++++++
 tests/baselines/reference/es3-jsx-preserve.types    | 13 +++++++++++++
 tests/baselines/reference/es3-jsx-react-native.js   | 11 +++++++++++
 .../reference/es3-jsx-react-native.symbols          | 11 +++++++++++
 .../baselines/reference/es3-jsx-react-native.types  | 13 +++++++++++++
 tests/baselines/reference/es3-jsx-react.js          | 11 +++++++++++
 tests/baselines/reference/es3-jsx-react.symbols     | 11 +++++++++++
 tests/baselines/reference/es3-jsx-react.types       | 13 +++++++++++++
 tests/cases/compiler/es3-jsx-preserve.tsx           |  9 +++++++++
 tests/cases/compiler/es3-jsx-react-native.tsx       |  9 +++++++++
 tests/cases/compiler/es3-jsx-react.tsx              |  9 +++++++++
 13 files changed, 134 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/es3-jsx-preserve.js
 create mode 100644 tests/baselines/reference/es3-jsx-preserve.symbols
 create mode 100644 tests/baselines/reference/es3-jsx-preserve.types
 create mode 100644 tests/baselines/reference/es3-jsx-react-native.js
 create mode 100644 tests/baselines/reference/es3-jsx-react-native.symbols
 create mode 100644 tests/baselines/reference/es3-jsx-react-native.types
 create mode 100644 tests/baselines/reference/es3-jsx-react.js
 create mode 100644 tests/baselines/reference/es3-jsx-react.symbols
 create mode 100644 tests/baselines/reference/es3-jsx-react.types
 create mode 100644 tests/cases/compiler/es3-jsx-preserve.tsx
 create mode 100644 tests/cases/compiler/es3-jsx-react-native.tsx
 create mode 100644 tests/cases/compiler/es3-jsx-react.tsx

diff --git a/src/compiler/transformers/es5.ts b/src/compiler/transformers/es5.ts
index 6dd875965d9..972b9214f16 100644
--- a/src/compiler/transformers/es5.ts
+++ b/src/compiler/transformers/es5.ts
@@ -14,7 +14,7 @@ namespace ts {
         // enable emit notification only if using --jsx preserve
         let previousOnEmitNode: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
         let noSubstitution: boolean[];
-        if (compilerOptions.jsx === JsxEmit.Preserve) {
+        if (compilerOptions.jsx === JsxEmit.Preserve || compilerOptions.jsx === JsxEmit.ReactNative) {
             previousOnEmitNode = context.onEmitNode;
             context.onEmitNode = onEmitNode;
             context.enableEmitNotification(SyntaxKind.JsxOpeningElement);
@@ -116,4 +116,4 @@ namespace ts {
             return undefined;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/baselines/reference/es3-jsx-preserve.js b/tests/baselines/reference/es3-jsx-preserve.js
new file mode 100644
index 00000000000..cb1ba2a887d
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-preserve.js
@@ -0,0 +1,11 @@
+//// [es3-jsx-preserve.tsx]
+
+const React: any = null;
+
+const elem = <div></div>;
+
+
+
+//// [es3-jsx-preserve.jsx]
+var React = null;
+var elem = <div></div>;
diff --git a/tests/baselines/reference/es3-jsx-preserve.symbols b/tests/baselines/reference/es3-jsx-preserve.symbols
new file mode 100644
index 00000000000..61c9260223f
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-preserve.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/es3-jsx-preserve.tsx ===
+
+const React: any = null;
+>React : Symbol(React, Decl(es3-jsx-preserve.tsx, 1, 5))
+
+const elem = <div></div>;
+>elem : Symbol(elem, Decl(es3-jsx-preserve.tsx, 3, 5))
+>div : Symbol(unknown)
+>div : Symbol(unknown)
+
+
diff --git a/tests/baselines/reference/es3-jsx-preserve.types b/tests/baselines/reference/es3-jsx-preserve.types
new file mode 100644
index 00000000000..b37fe8af567
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-preserve.types
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/es3-jsx-preserve.tsx ===
+
+const React: any = null;
+>React : any
+>null : null
+
+const elem = <div></div>;
+>elem : any
+><div></div> : any
+>div : any
+>div : any
+
+
diff --git a/tests/baselines/reference/es3-jsx-react-native.js b/tests/baselines/reference/es3-jsx-react-native.js
new file mode 100644
index 00000000000..08e6e25502b
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react-native.js
@@ -0,0 +1,11 @@
+//// [es3-jsx-react-native.tsx]
+
+const React: any = null;
+
+const elem = <div></div>;
+
+
+
+//// [es3-jsx-react-native.js]
+var React = null;
+var elem = <div></div>;
diff --git a/tests/baselines/reference/es3-jsx-react-native.symbols b/tests/baselines/reference/es3-jsx-react-native.symbols
new file mode 100644
index 00000000000..e7f010bd2ea
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react-native.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/es3-jsx-react-native.tsx ===
+
+const React: any = null;
+>React : Symbol(React, Decl(es3-jsx-react-native.tsx, 1, 5))
+
+const elem = <div></div>;
+>elem : Symbol(elem, Decl(es3-jsx-react-native.tsx, 3, 5))
+>div : Symbol(unknown)
+>div : Symbol(unknown)
+
+
diff --git a/tests/baselines/reference/es3-jsx-react-native.types b/tests/baselines/reference/es3-jsx-react-native.types
new file mode 100644
index 00000000000..1bf199606f2
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react-native.types
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/es3-jsx-react-native.tsx ===
+
+const React: any = null;
+>React : any
+>null : null
+
+const elem = <div></div>;
+>elem : any
+><div></div> : any
+>div : any
+>div : any
+
+
diff --git a/tests/baselines/reference/es3-jsx-react.js b/tests/baselines/reference/es3-jsx-react.js
new file mode 100644
index 00000000000..861dde74c86
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react.js
@@ -0,0 +1,11 @@
+//// [es3-jsx-react.tsx]
+
+const React: any = null;
+
+const elem = <div></div>;
+
+
+
+//// [es3-jsx-react.js]
+var React = null;
+var elem = React.createElement("div", null);
diff --git a/tests/baselines/reference/es3-jsx-react.symbols b/tests/baselines/reference/es3-jsx-react.symbols
new file mode 100644
index 00000000000..465cfab7ea9
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/es3-jsx-react.tsx ===
+
+const React: any = null;
+>React : Symbol(React, Decl(es3-jsx-react.tsx, 1, 5))
+
+const elem = <div></div>;
+>elem : Symbol(elem, Decl(es3-jsx-react.tsx, 3, 5))
+>div : Symbol(unknown)
+>div : Symbol(unknown)
+
+
diff --git a/tests/baselines/reference/es3-jsx-react.types b/tests/baselines/reference/es3-jsx-react.types
new file mode 100644
index 00000000000..b7734ffc1f0
--- /dev/null
+++ b/tests/baselines/reference/es3-jsx-react.types
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/es3-jsx-react.tsx ===
+
+const React: any = null;
+>React : any
+>null : null
+
+const elem = <div></div>;
+>elem : any
+><div></div> : any
+>div : any
+>div : any
+
+
diff --git a/tests/cases/compiler/es3-jsx-preserve.tsx b/tests/cases/compiler/es3-jsx-preserve.tsx
new file mode 100644
index 00000000000..f6092e692b4
--- /dev/null
+++ b/tests/cases/compiler/es3-jsx-preserve.tsx
@@ -0,0 +1,9 @@
+// @target: ES3
+// @sourcemap: false
+// @declaration: false
+// @jsx: preserve
+
+const React: any = null;
+
+const elem = <div></div>;
+
diff --git a/tests/cases/compiler/es3-jsx-react-native.tsx b/tests/cases/compiler/es3-jsx-react-native.tsx
new file mode 100644
index 00000000000..9ed0f9e003d
--- /dev/null
+++ b/tests/cases/compiler/es3-jsx-react-native.tsx
@@ -0,0 +1,9 @@
+// @target: ES3
+// @sourcemap: false
+// @declaration: false
+// @jsx: react-native
+
+const React: any = null;
+
+const elem = <div></div>;
+
diff --git a/tests/cases/compiler/es3-jsx-react.tsx b/tests/cases/compiler/es3-jsx-react.tsx
new file mode 100644
index 00000000000..d47aea9613f
--- /dev/null
+++ b/tests/cases/compiler/es3-jsx-react.tsx
@@ -0,0 +1,9 @@
+// @target: ES3
+// @sourcemap: false
+// @declaration: false
+// @jsx: react
+
+const React: any = null;
+
+const elem = <div></div>;
+

From 6fda5a1b3a3018623e3b3d49ab9520a9af24510c Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Mon, 23 Jan 2017 22:14:51 +0100
Subject: [PATCH 098/159] Update comment about jsx react-native in es5.ts

---
 src/compiler/transformers/es5.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/transformers/es5.ts b/src/compiler/transformers/es5.ts
index 972b9214f16..c3b011fe36d 100644
--- a/src/compiler/transformers/es5.ts
+++ b/src/compiler/transformers/es5.ts
@@ -11,7 +11,7 @@ namespace ts {
     export function transformES5(context: TransformationContext) {
         const compilerOptions = context.getCompilerOptions();
 
-        // enable emit notification only if using --jsx preserve
+        // enable emit notification only if using --jsx preserve or react-native
         let previousOnEmitNode: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
         let noSubstitution: boolean[];
         if (compilerOptions.jsx === JsxEmit.Preserve || compilerOptions.jsx === JsxEmit.ReactNative) {

From 77a504bb6495c277d5c8742426cf58162edbd06a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 20 Jan 2017 14:58:07 -0800
Subject: [PATCH 099/159] Clean up code in findAllReferences

---
 src/services/findAllReferences.ts | 217 ++++++++++++++++--------------
 src/services/utilities.ts         |   2 +-
 2 files changed, 115 insertions(+), 104 deletions(-)

diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 82a5da453b7..3c38c4e7536 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -7,30 +7,9 @@ namespace ts.FindAllReferences {
 
     export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean, implementations: boolean): ReferencedSymbol[] | undefined {
         if (!implementations) {
-            if (isTypeKeyword(node.kind)) {
-                return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken);
-            }
-
-            // Labels
-            if (isLabelName(node)) {
-                if (isJumpStatementTarget(node)) {
-                    const labelDefinition = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>node).text);
-                    // if we have a label definition, look within its statement for references, if not, then
-                    // the label is undefined and we have no results..
-                    return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition, cancellationToken);
-                }
-                else {
-                    // it is a label definition and not a target, search within the parent labeledStatement
-                    return getLabelReferencesInNode(node.parent, <Identifier>node, cancellationToken);
-                }
-            }
-
-            if (isThis(node)) {
-                return getReferencesForThisKeyword(node, sourceFiles, typeChecker, cancellationToken);
-            }
-
-            if (node.kind === SyntaxKind.SuperKeyword) {
-                return getReferencesForSuperKeyword(node, typeChecker, cancellationToken);
+            const special = getReferencedSymbolsSpecial(node, sourceFiles, typeChecker, cancellationToken);
+            if (special) {
+                return special;
             }
         }
 
@@ -69,9 +48,8 @@ namespace ts.FindAllReferences {
         // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
         const symbolToIndex: number[] = [];
 
-        let result: ReferencedSymbol[];
+        const result: ReferencedSymbol[] = [];
         if (scope) {
-            result = [];
             getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
         }
         else {
@@ -79,7 +57,6 @@ namespace ts.FindAllReferences {
             for (const sourceFile of sourceFiles) {
                 cancellationToken.throwIfCancellationRequested();
                 if (sourceFileHasName(sourceFile, internedName)) {
-                    result = result || [];
                     getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
                 }
             }
@@ -88,6 +65,37 @@ namespace ts.FindAllReferences {
         return result;
     }
 
+    /** getReferencedSymbols for special node kinds. */
+    function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], typeChecker: TypeChecker, cancellationToken: CancellationToken): ReferencedSymbol[] | undefined {
+        if (isTypeKeyword(node.kind)) {
+            return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken);
+        }
+
+        // Labels
+        if (isLabelName(node)) {
+            if (isJumpStatementTarget(node)) {
+                const labelDefinition = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>node).text);
+                // if we have a label definition, look within its statement for references, if not, then
+                // the label is undefined and we have no results..
+                return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition, cancellationToken);
+            }
+            else {
+                // it is a label definition and not a target, search within the parent labeledStatement
+                return getLabelReferencesInNode(node.parent, <Identifier>node, cancellationToken);
+            }
+        }
+
+        if (isThis(node)) {
+            return getReferencesForThisKeyword(node, sourceFiles, typeChecker, cancellationToken);
+        }
+
+        if (node.kind === SyntaxKind.SuperKeyword) {
+            return getReferencesForSuperKeyword(node, typeChecker, cancellationToken);
+        }
+
+        return undefined;
+    }
+
     function sourceFileHasName(sourceFile: SourceFile, name: string): boolean {
         return getNameTable(sourceFile).get(name) !== undefined;
     }
@@ -166,7 +174,7 @@ namespace ts.FindAllReferences {
         // If this is an export or import specifier it could have been renamed using the 'as' syntax.
         // If so we want to search for whatever under the cursor.
         if (isImportOrExportSpecifierName(location)) {
-            return location.getText();
+            return location.text;
         }
 
         // Try to get the local symbol if we're dealing with an 'export default'
@@ -401,6 +409,9 @@ namespace ts.FindAllReferences {
         const inheritsFromCache: Map<boolean> = createMap<boolean>();
         // Build the set of symbols to search for, initially it has only the current symbol
         const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation, typeChecker, implementations);
+        function isSearchedFor(symbol: Symbol): boolean {
+            return contains(searchSymbols, symbol);
+        }
 
         for (const position of possiblePositions) {
             cancellationToken.throwIfCancellationRequested();
@@ -438,7 +449,7 @@ namespace ts.FindAllReferences {
             if (referenceSymbol) {
                 const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
                 const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
-                const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
+                const relatedSymbol = getRelatedSymbol(isSearchedFor, referenceSymbol, referenceLocation,
                     /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker);
 
                 if (relatedSymbol) {
@@ -450,7 +461,7 @@ namespace ts.FindAllReferences {
                     * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
                     * position of property accessing, the referenceEntry of such position will be handled in the first case.
                     */
-                else if (!(referenceSymbol.flags & SymbolFlags.Transient) && searchSymbols.indexOf(shorthandValueSymbol) >= 0) {
+                else if (!(referenceSymbol.flags & SymbolFlags.Transient) && isSearchedFor(shorthandValueSymbol)) {
                     addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
                 }
                 else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
@@ -482,10 +493,6 @@ namespace ts.FindAllReferences {
             }
         }
 
-        function getPropertyAccessExpressionFromRightHandSide(node: Node): PropertyAccessExpression {
-            return isRightSideOfPropertyAccess(node) && <PropertyAccessExpression>node.parent;
-        }
-
         /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses.  */
         function findAdditionalConstructorReferences(referenceSymbol: Symbol, referenceLocation: Node): void {
             Debug.assert(isClassLike(searchSymbol.valueDeclaration));
@@ -494,7 +501,7 @@ namespace ts.FindAllReferences {
             if (referenceSymbol === searchSymbol && isClassLike(referenceClass)) {
                 Debug.assert(referenceClass.name === referenceLocation);
                 // This is the class declaration containing the constructor.
-                addReferences(findOwnConstructorCalls(searchSymbol));
+                addReferences(findOwnConstructorCalls(searchSymbol, sourceFile));
             }
             else {
                 // If this class appears in `extends C`, then the extending class' "super" calls are references.
@@ -512,58 +519,6 @@ namespace ts.FindAllReferences {
             }
         }
 
-        /** `classSymbol` is the class where the constructor was defined.
-         * Reference the constructor and all calls to `new this()`.
-         */
-        function findOwnConstructorCalls(classSymbol: Symbol): Node[] {
-            const result: Node[] = [];
-
-            for (const decl of classSymbol.members.get("__constructor").declarations) {
-                const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)!
-                Debug.assert(decl.kind === SyntaxKind.Constructor && !!ctrKeyword);
-                result.push(ctrKeyword);
-            }
-
-            classSymbol.exports.forEach(member => {
-                const decl = member.valueDeclaration;
-                if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
-                    const body = (<MethodDeclaration>decl).body;
-                    if (body) {
-                        forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => {
-                            if (isNewExpressionTarget(thisKeyword)) {
-                                result.push(thisKeyword);
-                            }
-                        });
-                    }
-                }
-            });
-
-            return result;
-        }
-
-        /** Find references to `super` in the constructor of an extending class.  */
-        function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
-            const symbol = cls.symbol;
-            const ctr = symbol.members.get("__constructor");
-            if (!ctr) {
-                return [];
-            }
-
-            const result: Node[] = [];
-            for (const decl of ctr.declarations) {
-                Debug.assert(decl.kind === SyntaxKind.Constructor);
-                const body = (<ConstructorDeclaration>decl).body;
-                if (body) {
-                    forEachDescendantOfKind(body, SyntaxKind.SuperKeyword, node => {
-                        if (isCallExpressionTarget(node)) {
-                            result.push(node);
-                        }
-                    });
-                }
-            };
-            return result;
-        }
-
         function getReferencedSymbol(symbol: Symbol): ReferencedSymbol {
             const symbolId = getSymbolId(symbol);
             let index = symbolToIndex[symbolId];
@@ -591,6 +546,62 @@ namespace ts.FindAllReferences {
         }
     }
 
+    function getPropertyAccessExpressionFromRightHandSide(node: Node): PropertyAccessExpression {
+        return isRightSideOfPropertyAccess(node) && <PropertyAccessExpression>node.parent;
+    }
+
+    /** `classSymbol` is the class where the constructor was defined.
+     * Reference the constructor and all calls to `new this()`.
+     */
+    function findOwnConstructorCalls(classSymbol: Symbol, sourceFile: SourceFile): Node[] {
+        const result: Node[] = [];
+
+        for (const decl of classSymbol.members.get("__constructor").declarations) {
+            const ctrKeyword = ts.findChildOfKind(decl, ts.SyntaxKind.ConstructorKeyword, sourceFile)!
+            Debug.assert(decl.kind === SyntaxKind.Constructor && !!ctrKeyword);
+            result.push(ctrKeyword);
+        }
+
+        classSymbol.exports.forEach(member => {
+            const decl = member.valueDeclaration;
+            if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
+                const body = (<MethodDeclaration>decl).body;
+                if (body) {
+                    forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => {
+                        if (isNewExpressionTarget(thisKeyword)) {
+                            result.push(thisKeyword);
+                        }
+                    });
+                }
+            }
+        });
+
+        return result;
+    }
+
+    /** Find references to `super` in the constructor of an extending class.  */
+    function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
+        const symbol = cls.symbol;
+        const ctr = symbol.members.get("__constructor");
+        if (!ctr) {
+            return [];
+        }
+
+        const result: Node[] = [];
+        for (const decl of ctr.declarations) {
+            Debug.assert(decl.kind === SyntaxKind.Constructor);
+            const body = (<ConstructorDeclaration>decl).body;
+            if (body) {
+                forEachDescendantOfKind(body, SyntaxKind.SuperKeyword, node => {
+                    if (isCallExpressionTarget(node)) {
+                        result.push(node);
+                    }
+                });
+            }
+        };
+        return result;
+    }
+
     function getImplementationReferenceEntryForNode(refNode: Node, result: ReferenceEntry[], typeChecker: TypeChecker): void {
         // Check if we found a function/propertyAssignment/method with an implementation or initializer
         if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
@@ -805,13 +816,13 @@ namespace ts.FindAllReferences {
 
         const sourceFile = searchSpaceNode.getSourceFile();
         const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken);
-        forEach(possiblePositions, position => {
+        for (const position of possiblePositions) {
             cancellationToken.throwIfCancellationRequested();
 
             const node = getTouchingWord(sourceFile, position);
 
             if (!node || node.kind !== SyntaxKind.SuperKeyword) {
-                return;
+                continue;
             }
 
             const container = getSuperContainer(node, /*stopOnFunctions*/ false);
@@ -822,7 +833,7 @@ namespace ts.FindAllReferences {
             if (container && (ModifierFlags.Static & getModifierFlags(container)) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
                 references.push(getReferenceEntryFromNode(node));
             }
-        });
+        }
 
         const definition = getDefinition(searchSpaceNode.symbol, superKeyword, typeChecker);
         return [{ definition, references }];
@@ -1057,7 +1068,7 @@ namespace ts.FindAllReferences {
 
         // If this is a union property, add all the symbols from all its source symbols in all unioned types.
         // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
-        forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
+        for (const rootSymbol of typeChecker.getRootSymbols(symbol)) {
             if (rootSymbol !== symbol) {
                 result.push(rootSymbol);
             }
@@ -1066,7 +1077,7 @@ namespace ts.FindAllReferences {
             if (!implementations && rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
                 getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
             }
-        });
+        }
 
         return result;
     }
@@ -1130,17 +1141,17 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>, typeChecker: TypeChecker): Symbol {
-        if (contains(searchSymbols, referenceSymbol)) {
+    function getRelatedSymbol(isSearchedFor: (symbol: Symbol) => boolean, referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>, typeChecker: TypeChecker): Symbol | undefined {
+        if (isSearchedFor(referenceSymbol)) {
             // If we are searching for constructor uses, they must be 'new' expressions.
-            return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) && referenceSymbol;
+            return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) ? referenceSymbol : undefined;
         }
 
         // If the reference symbol is an alias, check if what it is aliasing is one of the search
         // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness.
         const aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation, typeChecker);
         if (aliasSymbol) {
-            return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker);
+            return getRelatedSymbol(isSearchedFor, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker);
         }
 
         // If the reference location is in an object literal, try to get the contextual type for the
@@ -1148,9 +1159,8 @@ namespace ts.FindAllReferences {
         // compare to our searchSymbol
         const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
         if (containingObjectLiteralElement) {
-            const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol => {
-                return forEach(typeChecker.getRootSymbols(contextualSymbol), s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
-            });
+            const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol =>
+                find(typeChecker.getRootSymbols(contextualSymbol), isSearchedFor));
 
             if (contextualSymbol) {
                 return contextualSymbol;
@@ -1161,7 +1171,7 @@ namespace ts.FindAllReferences {
             // In below eg. get 'property' from type of elems iterating type
             //      for ( { property: p2 } of elems) { }
             const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, typeChecker);
-            if (propertySymbol && searchSymbols.indexOf(propertySymbol) >= 0) {
+            if (propertySymbol && isSearchedFor(propertySymbol)) {
                 return propertySymbol;
             }
         }
@@ -1170,7 +1180,7 @@ namespace ts.FindAllReferences {
         // then include the binding element in the related symbols
         //      let { a } : { a };
         const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, typeChecker);
-        if (bindingElementPropertySymbol && searchSymbols.indexOf(bindingElementPropertySymbol) >= 0) {
+        if (bindingElementPropertySymbol && isSearchedFor(bindingElementPropertySymbol)) {
             return bindingElementPropertySymbol;
         }
 
@@ -1178,7 +1188,7 @@ namespace ts.FindAllReferences {
         // Or a union property, use its underlying unioned symbols
         return forEach(typeChecker.getRootSymbols(referenceSymbol), rootSymbol => {
             // if it is in the list, then we are done
-            if (searchSymbols.indexOf(rootSymbol) >= 0) {
+            if (isSearchedFor(rootSymbol)) {
                 return rootSymbol;
             }
 
@@ -1195,7 +1205,7 @@ namespace ts.FindAllReferences {
 
                 const result: Symbol[] = [];
                 getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
-                return forEach(result, s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
+                return find(result, isSearchedFor);
             }
 
             return undefined;
@@ -1214,6 +1224,7 @@ namespace ts.FindAllReferences {
         return (<Identifier | LiteralExpression>node.name).text;
     }
 
+    /** Gets all symbols for one property. Does not get symbols for every property. */
     function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] {
         const objectLiteral = <ObjectLiteralExpression>node.parent;
         const contextualType = typeChecker.getContextualType(objectLiteral);
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index a1680da69c3..f83f9ef8231 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -1319,7 +1319,7 @@ namespace ts {
         return name;
     }
 
-    export function isImportOrExportSpecifierName(location: Node): boolean {
+    export function isImportOrExportSpecifierName(location: Node): location is Identifier {
         return location.parent &&
             (location.parent.kind === SyntaxKind.ImportSpecifier || location.parent.kind === SyntaxKind.ExportSpecifier) &&
             (<ImportOrExportSpecifier>location.parent).propertyName === location;

From 0ca4cb25d68f370ac6bc5013f71f43b96b6f1e7a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 23 Jan 2017 13:23:26 -0800
Subject: [PATCH 100/159] Support find-all-references for default exports

---
 src/compiler/utilities.ts                     |   8 +-
 src/services/findAllReferences.ts             | 114 ++++++++++--------
 .../fourslash/findAllRefsForDefaultExport.ts  |  11 ++
 3 files changed, 82 insertions(+), 51 deletions(-)
 create mode 100644 tests/cases/fourslash/findAllRefsForDefaultExport.ts

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b7cc0f0de6d..5c63d8bb60c 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -395,7 +395,7 @@ namespace ts {
 
     function isShorthandAmbientModule(node: Node): boolean {
         // The only kind of module that can be missing a body is a shorthand ambient module.
-        return node.kind === SyntaxKind.ModuleDeclaration && (!(<ModuleDeclaration>node).body);
+        return node && node.kind === SyntaxKind.ModuleDeclaration && (!(<ModuleDeclaration>node).body);
     }
 
     export function isBlockScopedContainerTopLevel(node: Node): boolean {
@@ -3104,7 +3104,11 @@ namespace ts {
     }
 
     export function getLocalSymbolForExportDefault(symbol: Symbol) {
-        return symbol && symbol.valueDeclaration && hasModifier(symbol.valueDeclaration, ModifierFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
+        return isExportDefaultSymbol(symbol) ? symbol.valueDeclaration.localSymbol : undefined;
+    }
+
+    export function isExportDefaultSymbol(symbol: Symbol): boolean {
+        return symbol && symbol.valueDeclaration && hasModifier(symbol.valueDeclaration, ModifierFlags.Default);
     }
 
     /** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 3c38c4e7536..83006c66d77 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -15,14 +15,13 @@ namespace ts.FindAllReferences {
 
         // `getSymbolAtLocation` normally returns the symbol of the class when given the constructor keyword,
         // so we have to specify that we want the constructor symbol.
-        const symbol = typeChecker.getSymbolAtLocation(node);
-
-        if (!implementations && !symbol && node.kind === SyntaxKind.StringLiteral) {
-            return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, typeChecker, cancellationToken);
-        }
+        let symbol = typeChecker.getSymbolAtLocation(node);
 
         // Could not find a symbol e.g. unknown identifier
         if (!symbol) {
+            if (!implementations && node.kind === SyntaxKind.StringLiteral) {
+                return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, typeChecker, cancellationToken);
+            }
             // Can't have references to something that we have no symbol for.
             return undefined;
         }
@@ -34,9 +33,27 @@ namespace ts.FindAllReferences {
             return undefined;
         }
 
+        const aliasedSymbol = followAliasIfNecessary(symbol, node, typeChecker);
+        const isShorthandModule = ts.isShorthandAmbientModuleSymbol(aliasedSymbol);
+        // Don't follow alias for shorthand modules because we lose information that way.
+        if (!isShorthandModule) {
+            symbol = aliasedSymbol;
+        }
+
         // Compute the meaning from the location and the symbol it references
         const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
 
+        const result: ReferencedSymbol[] = [];
+        // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
+        const symbolToIndex: number[] = [];
+        const inheritsFromCache: Map<boolean> = createMap<boolean>();
+
+        // Build the set of symbols to search for, initially it has only the current symbol
+        const searchSymbols = populateSearchSymbolSet(symbol, node, typeChecker, implementations, isShorthandModule ? aliasedSymbol : undefined);
+        function isSearchedFor(symbol: Symbol): boolean {
+            return contains(searchSymbols, symbol);
+        }
+
         // Get the text to search for.
         // Note: if this is an external module symbol, the name doesn't include quotes.
         const declaredName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
@@ -44,25 +61,28 @@ namespace ts.FindAllReferences {
         // Try to get the smallest valid scope that we can limit our search to;
         // otherwise we'll need to search globally (i.e. include each file).
         const scope = getSymbolScope(symbol);
-
-        // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
-        const symbolToIndex: number[] = [];
-
-        const result: ReferencedSymbol[] = [];
         if (scope) {
-            getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
+            getRefs(scope, declaredName);
         }
         else {
-            const internedName = getInternedName(symbol, node);
+            const isDefault = isExportDefaultSymbol(symbol);
+            const internedName = isDefault ? symbol.valueDeclaration.localSymbol.name : getInternedName(symbol, node);
             for (const sourceFile of sourceFiles) {
                 cancellationToken.throwIfCancellationRequested();
-                if (sourceFileHasName(sourceFile, internedName)) {
-                    getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex, implementations, typeChecker, cancellationToken);
+                const searchName = (isDefault ? getDefaultImportName(symbol, sourceFile, typeChecker) : undefined) ||
+                    (sourceFileHasName(sourceFile, internedName) ? declaredName : undefined);
+                if (searchName !== undefined) {
+                    getRefs(sourceFile, searchName);
                 }
             }
         }
 
         return result;
+
+        function getRefs(scope: ts.Node, searchName: string): void {
+            getReferencesInNode(scope, symbol, searchName, node, searchMeaning, findInStrings, findInComments, result,
+                symbolToIndex, implementations, typeChecker, cancellationToken, isSearchedFor, inheritsFromCache);
+        }
     }
 
     /** getReferencedSymbols for special node kinds. */
@@ -100,6 +120,23 @@ namespace ts.FindAllReferences {
         return getNameTable(sourceFile).get(name) !== undefined;
     }
 
+    /**
+     * Given a symbol, see if any of the imports in a source file reference it.
+     * Only call this if `symbol` is a default export.
+     */
+    function getDefaultImportName(symbol: Symbol, sourceFile: SourceFile, checker: ts.TypeChecker): string | undefined {
+        for (const importSpecifier of sourceFile.imports) {
+            const importDecl = importSpecifier.parent as ts.ImportDeclaration;
+            Debug.assert(importDecl.moduleSpecifier === importSpecifier);
+            const defaultName = importDecl.importClause.name;
+            const defaultReferencedSymbol = checker.getAliasedSymbol(checker.getSymbolAtLocation(defaultName));
+            if (symbol === defaultReferencedSymbol) {
+                return defaultName.text;
+            }
+        }
+        return undefined;
+    }
+
     function getDefinition(symbol: Symbol, node: Node, typeChecker: TypeChecker): ReferencedSymbolDefinitionInfo {
         const { displayParts, symbolKind } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, node.getSourceFile(), getContainerNode(node), node);
         const name = displayParts.map(p => p.text).join("");
@@ -177,11 +214,6 @@ namespace ts.FindAllReferences {
             return location.text;
         }
 
-        // Try to get the local symbol if we're dealing with an 'export default'
-        // since that symbol has the "true" name.
-        const localExportDefaultSymbol = getLocalSymbolForExportDefault(symbol);
-        symbol = localExportDefaultSymbol || symbol;
-
         return stripQuotes(symbol.name);
     }
 
@@ -398,7 +430,9 @@ namespace ts.FindAllReferences {
         symbolToIndex: number[],
         implementations: boolean,
         typeChecker: TypeChecker,
-        cancellationToken: CancellationToken): void {
+        cancellationToken: CancellationToken,
+        isSearchedFor: (symbol: Symbol) => boolean,
+        inheritsFromCache: Map<boolean>): void {
 
         const sourceFile = container.getSourceFile();
 
@@ -406,12 +440,6 @@ namespace ts.FindAllReferences {
         const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd(), cancellationToken);
 
         const parents = getParentSymbolsOfPropertyAccess();
-        const inheritsFromCache: Map<boolean> = createMap<boolean>();
-        // Build the set of symbols to search for, initially it has only the current symbol
-        const searchSymbols = populateSearchSymbolSet(searchSymbol, searchLocation, typeChecker, implementations);
-        function isSearchedFor(symbol: Symbol): boolean {
-            return contains(searchSymbols, symbol);
-        }
 
         for (const position of possiblePositions) {
             cancellationToken.throwIfCancellationRequested();
@@ -456,11 +484,11 @@ namespace ts.FindAllReferences {
                     addReferenceToRelatedSymbol(referenceLocation, relatedSymbol);
                 }
                 /* Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
-                    * has two meaning : property name and property value. Therefore when we do findAllReference at the position where
-                    * an identifier is declared, the language service should return the position of the variable declaration as well as
-                    * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
-                    * position of property accessing, the referenceEntry of such position will be handled in the first case.
-                    */
+                 * has two meanings: property name and property value. Therefore when we do findAllReference at the position where
+                 * an identifier is declared, the language service should return the position of the variable declaration as well as
+                 * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
+                 * position of property accessing, the referenceEntry of such position will be handled in the first case.
+                 */
                 else if (!(referenceSymbol.flags & SymbolFlags.Transient) && isSearchedFor(shorthandValueSymbol)) {
                     addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
                 }
@@ -472,10 +500,10 @@ namespace ts.FindAllReferences {
         return;
 
         /* If we are just looking for implementations and this is a property access expression, we need to get the
-            * symbol of the local type of the symbol the property is being accessed on. This is because our search
-            * symbol may have a different parent symbol if the local type's symbol does not declare the property
-            * being accessed (i.e. it is declared in some parent class or interface)
-            */
+         * symbol of the local type of the symbol the property is being accessed on. This is because our search
+         * symbol may have a different parent symbol if the local type's symbol does not declare the property
+         * being accessed (i.e. it is declared in some parent class or interface)
+         */
         function getParentSymbolsOfPropertyAccess(): Symbol[] | undefined {
             if (implementations) {
                 const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(searchLocation);
@@ -994,7 +1022,7 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean): Symbol[] {
+    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean, aliasSymbol?: Symbol): Symbol[] {
         // The search set contains at least the current symbol
         let result = [symbol];
 
@@ -1009,18 +1037,6 @@ namespace ts.FindAllReferences {
             }
         }
 
-        // If the symbol is an alias, add what it aliases to the list
-        //     import {a} from "mod";
-        //     export {a}
-        // If the symbol is an alias to default declaration, add what it aliases to the list
-        //     declare "mod" { export default class B { } }
-        //     import B from "mod";
-        //// For export specifiers, the exported name can be referring to a local symbol, e.g.:
-        ////     import {a} from "mod";
-        ////     export {a as somethingElse}
-        //// We want the *local* declaration of 'a' as declared in the import,
-        //// *not* as declared within "mod" (or farther)
-        const aliasSymbol = getAliasSymbolForPropertyNameSymbol(symbol, location, typeChecker);
         if (aliasSymbol) {
             result = result.concat(populateSearchSymbolSet(aliasSymbol, location, typeChecker, implementations));
         }
@@ -1225,7 +1241,7 @@ namespace ts.FindAllReferences {
     }
 
     /** Gets all symbols for one property. Does not get symbols for every property. */
-    function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] {
+    function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] | undefined {
         const objectLiteral = <ObjectLiteralExpression>node.parent;
         const contextualType = typeChecker.getContextualType(objectLiteral);
         const name = getNameFromObjectLiteralElement(node);
diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport.ts b/tests/cases/fourslash/findAllRefsForDefaultExport.ts
new file mode 100644
index 00000000000..a27227b907a
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsForDefaultExport.ts
@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: a.ts
+////export default function /*def*/[|f|]() {}
+
+// @Filename: b.ts
+////import [|g|] from "./a";
+/////*ref*/[|g|]();
+
+verify.rangesReferenceEachOther();
+verify.goToDefinition("ref", "def");

From da05ced2e5b8807af3698963515bc71da0997a0d Mon Sep 17 00:00:00 2001
From: falsandtru <falsandtru@users.noreply.github.com>
Date: Wed, 18 Jan 2017 12:05:25 +0900
Subject: [PATCH 101/159] Fix Symbol.valueOf method signature

---
 src/lib/es2015.symbol.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/es2015.symbol.d.ts b/src/lib/es2015.symbol.d.ts
index cd7e45595f0..d7ea4fa0328 100644
--- a/src/lib/es2015.symbol.d.ts
+++ b/src/lib/es2015.symbol.d.ts
@@ -3,7 +3,7 @@ interface Symbol {
     toString(): string;
 
     /** Returns the primitive value of the specified object. */
-    valueOf(): Object;
+    valueOf(): symbol;
 }
 
 interface SymbolConstructor {

From 053b3cd893d00b63dda48085c744844128aaba43 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 23 Jan 2017 16:01:29 -0800
Subject: [PATCH 102/159] getFirstToken skips JSDoc

Fixes #13519.
This is a better fix than #13599.
Also fixes broken tests associated with #13599.
---
 src/harness/unittests/jsDocParsing.ts | 13 +++++++++----
 src/services/services.ts              |  8 +++-----
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/harness/unittests/jsDocParsing.ts b/src/harness/unittests/jsDocParsing.ts
index 3cafc9d49ae..98c32c77778 100644
--- a/src/harness/unittests/jsDocParsing.ts
+++ b/src/harness/unittests/jsDocParsing.ts
@@ -290,16 +290,21 @@ namespace ts {
         });
         describe("getFirstToken", () => {
             it("gets jsdoc", () => {
-                const first = ts.createSourceFile("foo.ts", "/** comment */var a = true;", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                const root = ts.createSourceFile("foo.ts", "/** comment */var a = true;", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                assert.isDefined(root);
+                assert.equal(root.kind, ts.SyntaxKind.SourceFile);
+                const first = root.getFirstToken();
                 assert.isDefined(first);
-                assert.equal(first.kind, 263);
+                assert.equal(first.kind, ts.SyntaxKind.VarKeyword);
             });
         });
         describe("getLastToken", () => {
             it("gets jsdoc", () => {
-                const last = ts.createSourceFile("foo.ts", "var a = true;/** comment */", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                const root = ts.createSourceFile("foo.ts", "var a = true;/** comment */", ts.ScriptTarget.ES5, /*setParentNodes*/ true);
+                assert.isDefined(root);
+                const last = root.getLastToken();
                 assert.isDefined(last);
-                assert.equal(last.kind, 263);
+                assert.equal(last.kind, ts.SyntaxKind.EndOfFileToken);
             });
         });
     });
diff --git a/src/services/services.ts b/src/services/services.ts
index cb38b1d500e..208e1031cd2 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -193,8 +193,8 @@ namespace ts {
                 return undefined;
             }
 
-            const child = children[0];
-            return child.kind < SyntaxKind.FirstNode || SyntaxKind.FirstJSDocNode <= child.kind && child.kind <= SyntaxKind.LastJSDocNode ?
+            const child = ts.find(children, kid => kid.kind < SyntaxKind.FirstJSDocNode || kid.kind > SyntaxKind.LastJSDocNode);
+            return child.kind < SyntaxKind.FirstNode ?
                 child :
                 child.getFirstToken(sourceFile);
         }
@@ -207,9 +207,7 @@ namespace ts {
                 return undefined;
             }
 
-            return child.kind < SyntaxKind.FirstNode || SyntaxKind.FirstJSDocNode <= child.kind && child.kind <= SyntaxKind.LastJSDocNode ?
-                child :
-                child.getLastToken(sourceFile);
+            return child.kind < SyntaxKind.FirstNode ? child : child.getLastToken(sourceFile);
         }
     }
 

From 24bb21c55a1842393d523d8b4a26f5f230d24e10 Mon Sep 17 00:00:00 2001
From: Herrington Darkholme <nonamesheep1@gmail.com>
Date: Tue, 24 Jan 2017 11:24:30 +0800
Subject: [PATCH 103/159] address code review

---
 src/compiler/checker.ts                               | 11 +++++++----
 tests/baselines/reference/objectSpread.js             |  5 ++---
 tests/baselines/reference/objectSpread.symbols        |  5 ++---
 tests/baselines/reference/objectSpread.types          |  7 +++----
 .../reference/objectSpreadNegative.errors.txt         |  4 ++--
 tests/cases/conformance/types/spread/objectSpread.ts  |  3 +--
 6 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 97ca01bc086..1a1cea4633f 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6291,6 +6291,9 @@ namespace ts {
             if (right.flags & TypeFlags.Union) {
                 return mapType(right, t => getSpreadType(left, t));
             }
+            if (right.flags & TypeFlags.NonPrimitive) {
+                return emptyObjectType;
+            }
 
             const members = createMap<Symbol>();
             const skippedPrivateMembers = createMap<boolean>();
@@ -15719,12 +15722,12 @@ namespace ts {
             }
         }
 
-        /** 
+        /**
          * Static members being set on a constructor function may conflict with built-in properties
-         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable 
-         * built-in properties. This check issues a transpile error when a class has a static 
+         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable
+         * built-in properties. This check issues a transpile error when a class has a static
          * member with the same name as a non-writable built-in property.
-         * 
+         *
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
          * @see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
diff --git a/tests/baselines/reference/objectSpread.js b/tests/baselines/reference/objectSpread.js
index 259b86628a5..2bc3b9e11bd 100644
--- a/tests/baselines/reference/objectSpread.js
+++ b/tests/baselines/reference/objectSpread.js
@@ -79,8 +79,7 @@ let computedAfter: { a: number, b: string, "at the end": number } =
 let a = 12;
 let shortCutted: { a: number, b: string } = { ...o, a }
 // non primitive
-let spreadNonPrimitve = { ...<object>{}}
-
+let spreadNonPrimitive = { ...<object>{}};
 
 
 //// [objectSpread.js]
@@ -151,5 +150,5 @@ var computedAfter = __assign({}, o, (_c = { b: 'yeah' }, _c['at the end'] = 14,
 var a = 12;
 var shortCutted = __assign({}, o, { a: a });
 // non primitive
-var spreadNonPrimitve = __assign({}, {});
+var spreadNonPrimitive = __assign({}, {});
 var _a, _b, _c;
diff --git a/tests/baselines/reference/objectSpread.symbols b/tests/baselines/reference/objectSpread.symbols
index 69c9ed34341..1ec2520e166 100644
--- a/tests/baselines/reference/objectSpread.symbols
+++ b/tests/baselines/reference/objectSpread.symbols
@@ -317,7 +317,6 @@ let shortCutted: { a: number, b: string } = { ...o, a }
 >a : Symbol(a, Decl(objectSpread.ts, 78, 51))
 
 // non primitive
-let spreadNonPrimitve = { ...<object>{}}
->spreadNonPrimitve : Symbol(spreadNonPrimitve, Decl(objectSpread.ts, 80, 3))
-
+let spreadNonPrimitive = { ...<object>{}};
+>spreadNonPrimitive : Symbol(spreadNonPrimitive, Decl(objectSpread.ts, 80, 3))
 
diff --git a/tests/baselines/reference/objectSpread.types b/tests/baselines/reference/objectSpread.types
index 8a8df1a497f..950dab43465 100644
--- a/tests/baselines/reference/objectSpread.types
+++ b/tests/baselines/reference/objectSpread.types
@@ -408,10 +408,9 @@ let shortCutted: { a: number, b: string } = { ...o, a }
 >a : number
 
 // non primitive
-let spreadNonPrimitve = { ...<object>{}}
->spreadNonPrimitve : { constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }
->{ ...<object>{}} : { constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }
+let spreadNonPrimitive = { ...<object>{}};
+>spreadNonPrimitive : {}
+>{ ...<object>{}} : {}
 ><object>{} : object
 >{} : {}
 
-
diff --git a/tests/baselines/reference/objectSpreadNegative.errors.txt b/tests/baselines/reference/objectSpreadNegative.errors.txt
index 2b0960996ff..d9106d651a3 100644
--- a/tests/baselines/reference/objectSpreadNegative.errors.txt
+++ b/tests/baselines/reference/objectSpreadNegative.errors.txt
@@ -14,7 +14,7 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(37,19): error TS269
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(42,1): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '{}' has no compatible call signatures.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(46,12): error TS2339: Property 'b' does not exist on type '{}'.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(52,9): error TS2339: Property 'm' does not exist on type '{ p: number; }'.
-tests/cases/conformance/types/spread/objectSpreadNegative.ts(57,11): error TS2339: Property 'a' does not exist on type '{ constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }'.
+tests/cases/conformance/types/spread/objectSpreadNegative.ts(57,11): error TS2339: Property 'a' does not exist on type '{}'.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(61,14): error TS2698: Spread types may only be created from object types.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(64,14): error TS2698: Spread types may only be created from object types.
 
@@ -107,7 +107,7 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(64,14): error TS269
     let spreadObj = { ...obj };
     spreadObj.a; // error 'a' is not in {}
               ~
-!!! error TS2339: Property 'a' does not exist on type '{ constructor: Function; toString(): string; toLocaleString(): string; valueOf(): Object; hasOwnProperty(v: string): boolean; isPrototypeOf(v: Object): boolean; propertyIsEnumerable(v: string): boolean; }'.
+!!! error TS2339: Property 'a' does not exist on type '{}'.
     
     // generics
     function f<T, U>(t: T, u: U) {
diff --git a/tests/cases/conformance/types/spread/objectSpread.ts b/tests/cases/conformance/types/spread/objectSpread.ts
index c4562e6f196..59b93bdd9e4 100644
--- a/tests/cases/conformance/types/spread/objectSpread.ts
+++ b/tests/cases/conformance/types/spread/objectSpread.ts
@@ -79,5 +79,4 @@ let computedAfter: { a: number, b: string, "at the end": number } =
 let a = 12;
 let shortCutted: { a: number, b: string } = { ...o, a }
 // non primitive
-let spreadNonPrimitve = { ...<object>{}}
-
+let spreadNonPrimitive = { ...<object>{}};

From ebb666a9c2e01a5ae1358252e0dde6a3e83f11f1 Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Tue, 24 Jan 2017 05:09:30 +0100
Subject: [PATCH 104/159] delete fourslash testcase for --jsx react-native

---
 .../getEmitOutputTsxFile_ReactNative.baseline | 26 -------------------
 .../getEmitOutputTsxFile_ReactNative.ts       | 22 ----------------
 2 files changed, 48 deletions(-)
 delete mode 100644 tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline
 delete mode 100644 tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts

diff --git a/tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline b/tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline
deleted file mode 100644
index 88fb0f0daf6..00000000000
--- a/tests/baselines/reference/getEmitOutputTsxFile_ReactNative.baseline
+++ /dev/null
@@ -1,26 +0,0 @@
-EmitSkipped: false
-FileName : /tests/cases/fourslash/inputFile1.js.map
-{"version":3,"file":"inputFile1.js","sourceRoot":"","sources":["inputFile1.ts"],"names":[],"mappings":"AAAA,kBAAkB;AACjB,IAAI,CAAC,GAAW,CAAC,CAAC;AAClB;IAAA;IAGA,CAAC;IAAD,UAAC;AAAD,CAAC,AAHD,IAGC"}FileName : /tests/cases/fourslash/inputFile1.js
-// regular ts file
-var t = 5;
-var Bar = (function () {
-    function Bar() {
-    }
-    return Bar;
-}());
-//# sourceMappingURL=inputFile1.js.mapFileName : /tests/cases/fourslash/inputFile1.d.ts
-declare var t: number;
-declare class Bar {
-    x: string;
-    y: number;
-}
-
-EmitSkipped: false
-FileName : /tests/cases/fourslash/inputFile2.js.map
-{"version":3,"file":"inputFile2.js","sourceRoot":"","sources":["inputFile2.tsx"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,QAAQ,CAAC;AACjB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,CAAC,CAAC,EAAG,CAAA"}FileName : /tests/cases/fourslash/inputFile2.js
-var y = "my div";
-var x = <div name={y}/>;
-//# sourceMappingURL=inputFile2.js.mapFileName : /tests/cases/fourslash/inputFile2.d.ts
-declare var y: string;
-declare var x: any;
-
diff --git a/tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts b/tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts
deleted file mode 100644
index c2aac0e9d03..00000000000
--- a/tests/cases/fourslash/getEmitOutputTsxFile_ReactNative.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/// <reference path="fourslash.ts" />
-
-// @BaselineFile: getEmitOutputTsxFile_ReactNative.baseline
-// @declaration: true
-// @sourceMap: true
-// @jsx: react-native
-
-// @Filename: inputFile1.ts
-// @emitThisFile: true
-////// regular ts file
-//// var t: number = 5;
-//// class Bar {
-////    x : string;
-////    y : number
-//// }
-
-// @Filename: inputFile2.tsx
-// @emitThisFile: true
-//// var y = "my div";
-//// var x = <div name= {y} />
-
-verify.baselineGetEmitOutput();

From 0a4632fe79c0390db616812ee9a5d2dd1fc1cff6 Mon Sep 17 00:00:00 2001
From: David Sheldrick <david@futurice.com>
Date: Tue, 24 Jan 2017 07:16:15 +0100
Subject: [PATCH 105/159] revert change to lib/protocol.d.ts

---
 lib/protocol.d.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/protocol.d.ts b/lib/protocol.d.ts
index cd46ebcd366..d6c0246af34 100644
--- a/lib/protocol.d.ts
+++ b/lib/protocol.d.ts
@@ -1798,10 +1798,9 @@ declare namespace ts.server.protocol {
     namespace JsxEmit {
         type None = "None";
         type Preserve = "Preserve";
-        type ReactNative = "ReactNative";
         type React = "React";
     }
-    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React | JsxEmit.ReactNative;
+    type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
     namespace ModuleKind {
         type None = "None";
         type CommonJS = "CommonJS";
@@ -1881,4 +1880,4 @@ declare namespace ts {
 }
 import protocol = ts.server.protocol;
 export = protocol;
-export as namespace protocol;
+export as namespace protocol;
\ No newline at end of file

From 0d21c241b2954a1ba8b23f98c6a3f083de22d3bd Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 09:06:46 -0800
Subject: [PATCH 106/159] Support find-all-references on mapped types.

* Need to put a 'mappedTypeOrigin' property in SymbolLinks
---
 src/compiler/checker.ts                           | 15 ++++++++++++---
 src/compiler/types.ts                             |  1 +
 tests/cases/fourslash/findAllRefsForMappedType.ts |  9 +++++++++
 3 files changed, 22 insertions(+), 3 deletions(-)
 create mode 100644 tests/cases/fourslash/findAllRefsForMappedType.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index bd8ff7568f3..878e7d47273 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4618,12 +4618,14 @@ namespace ts {
             const typeParameter = getTypeParameterFromMappedType(type);
             const constraintType = getConstraintTypeFromMappedType(type);
             const templateType = getTemplateTypeFromMappedType(type);
-            const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
+            const modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T'
             const templateReadonly = !!type.declaration.readonlyToken;
             const templateOptional = !!type.declaration.questionToken;
             if (type.declaration.typeParameter.constraint.kind === SyntaxKind.TypeOperator) {
                 // We have a { [P in keyof T]: X }
-                forEachType(getLiteralTypeFromPropertyNames(modifiersType), addMemberForKeyType);
+                for (const propertySymbol of getPropertiesOfType(modifiersType)) {
+                    addMemberForKeyType(getLiteralTypeFromPropertyName(propertySymbol), propertySymbol);
+                }
                 if (getIndexInfoOfType(modifiersType, IndexKind.String)) {
                     addMemberForKeyType(stringType);
                 }
@@ -4638,7 +4640,7 @@ namespace ts {
             }
             setStructuredTypeMembers(type, members, emptyArray, emptyArray, stringIndexInfo, undefined);
 
-            function addMemberForKeyType(t: Type) {
+            function addMemberForKeyType(t: Type, propertySymbol?: Symbol) {
                 // Create a mapper from T to the current iteration type constituent. Then, if the
                 // mapped type is itself an instantiated type, combine the iteration mapper with the
                 // instantiation mapper.
@@ -4654,6 +4656,9 @@ namespace ts {
                     const prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | (isOptional ? SymbolFlags.Optional : 0), propName);
                     prop.type = propType;
                     prop.isReadonly = templateReadonly || modifiersProp && isReadonlySymbol(modifiersProp);
+                    if (propertySymbol) {
+                        prop.mappedTypeOrigin = propertySymbol;
+                    }
                     members.set(propName, prop);
                 }
                 else if (t.flags & TypeFlags.String) {
@@ -20230,6 +20235,10 @@ namespace ts {
                     const links = symbol as SymbolLinks;
                     return [links.leftSpread, links.rightSpread];
                 }
+                if ((symbol as SymbolLinks).mappedTypeOrigin) {
+                    return getRootSymbols((symbol as SymbolLinks).mappedTypeOrigin);
+                }
+
                 let target: Symbol;
                 let next = symbol;
                 while (next = getSymbolLinks(next).target) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 6ac7d573eda..8b49af402cf 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2712,6 +2712,7 @@
         containingType?: UnionOrIntersectionType;  // Containing union or intersection type for synthetic property
         leftSpread?: Symbol;                // Left source for synthetic spread property
         rightSpread?: Symbol;               // Right source for synthetic spread property
+        mappedTypeOrigin?: Symbol;          // For a property on a mapped type, points back to the orignal 'T' from 'keyof T'.
         hasNonUniformType?: boolean;        // True if constituents have non-uniform types
         isPartial?: boolean;                // True if syntheric property of union type occurs in some but not all constituents
         isDiscriminantProperty?: boolean;   // True if discriminant synthetic property
diff --git a/tests/cases/fourslash/findAllRefsForMappedType.ts b/tests/cases/fourslash/findAllRefsForMappedType.ts
new file mode 100644
index 00000000000..620eae0815c
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsForMappedType.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts'/>
+
+////interface T { [|a|]: number };
+////type U { [K in keyof T]: string };
+////type V = { [K in keyof U]: boolean };
+////const u: U = { [|a|]: "" }
+////const v: V = { [|a|]: true }
+
+verify.rangesReferenceEachOther();

From e8c3d548eb66c020b02cfa135b492f9480ef639c Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 12:56:21 -0800
Subject: [PATCH 107/159] Fix tests

---
 src/services/documentHighlights.ts            |   2 +-
 src/services/findAllReferences.ts             | 109 +++++++++++-------
 src/services/goToImplementation.ts            |   2 +-
 src/services/services.ts                      |  10 +-
 tests/cases/fourslash/renameDefaultImport.ts  |  17 ++-
 .../renameDefaultImportDifferentName.ts       |  14 ++-
 .../cases/fourslash/renameImportAndExport.ts  |   4 +-
 7 files changed, 104 insertions(+), 54 deletions(-)

diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 778a007ded5..ff2b819ec26 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -17,7 +17,7 @@ namespace ts.DocumentHighlights {
     }
 
     function getSemanticDocumentHighlights(node: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
-        const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/false, /*findInComments*/false, /*implementations*/false);
+        const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch);
         return referencedSymbols && convertReferencedSymbols(referencedSymbols);
     }
 
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 83006c66d77..df568f6df3e 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -1,11 +1,11 @@
 /* @internal */
 namespace ts.FindAllReferences {
-    export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] | undefined {
+    export function findReferencedSymbols(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, findInStrings: boolean, findInComments: boolean, isForRename: boolean): ReferencedSymbol[] | undefined {
         const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
-        return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, /*implementations*/false);
+        return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, isForRename);
     }
 
-    export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean, implementations: boolean): ReferencedSymbol[] | undefined {
+    export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings?: boolean, findInComments?: boolean, isForRename?: boolean, implementations?: boolean): ReferencedSymbol[] | undefined {
         if (!implementations) {
             const special = getReferencedSymbolsSpecial(node, sourceFiles, typeChecker, cancellationToken);
             if (special) {
@@ -33,11 +33,16 @@ namespace ts.FindAllReferences {
             return undefined;
         }
 
-        const aliasedSymbol = followAliasIfNecessary(symbol, node, typeChecker);
-        const isShorthandModule = ts.isShorthandAmbientModuleSymbol(aliasedSymbol);
-        // Don't follow alias for shorthand modules because we lose information that way.
-        if (!isShorthandModule) {
-            symbol = aliasedSymbol;
+        const { symbol: aliasedSymbol, shorthandModuleSymbol } = followAliases(symbol, node, typeChecker, isForRename);
+        symbol = aliasedSymbol;
+
+        // Build the set of symbols to search for, initially it has only the current symbol
+        const searchSymbols = populateSearchSymbolSet(symbol, node, typeChecker, implementations);
+        if (shorthandModuleSymbol) {
+            searchSymbols.push(shorthandModuleSymbol);
+        }
+        function isSearchedFor(symbol: Symbol): boolean {
+            return contains(searchSymbols, symbol);
         }
 
         // Compute the meaning from the location and the symbol it references
@@ -48,12 +53,6 @@ namespace ts.FindAllReferences {
         const symbolToIndex: number[] = [];
         const inheritsFromCache: Map<boolean> = createMap<boolean>();
 
-        // Build the set of symbols to search for, initially it has only the current symbol
-        const searchSymbols = populateSearchSymbolSet(symbol, node, typeChecker, implementations, isShorthandModule ? aliasedSymbol : undefined);
-        function isSearchedFor(symbol: Symbol): boolean {
-            return contains(searchSymbols, symbol);
-        }
-
         // Get the text to search for.
         // Note: if this is an external module symbol, the name doesn't include quotes.
         const declaredName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
@@ -116,6 +115,31 @@ namespace ts.FindAllReferences {
         return undefined;
     }
 
+    /**
+     * Follows aliases to get to the original declaration of a symbol.
+     * For a shorthand ambient module, we don't follow the alias to it, but we will need to add it to the set of search symbols.
+     */
+    function followAliases(symbol: Symbol, node: Node, typeChecker: TypeChecker, isForRename: boolean): { symbol: Symbol, shorthandModuleSymbol?: Symbol } {
+        while (true) {
+            // When renaming a default import, only rename in the current file
+            if (isForRename && isImportDefaultSymbol(symbol)) {
+                return { symbol };
+            }
+
+            const aliasedSymbol = getAliasSymbolForPropertyNameSymbol(symbol, node, typeChecker);
+            // Don't follow alias if it goes to unknown symbol. This can happen if it points to an untyped module.
+            if (!aliasedSymbol || !aliasedSymbol.declarations) {
+                return { symbol };
+            }
+
+            if (ts.isShorthandAmbientModuleSymbol(aliasedSymbol)) {
+                return { symbol, shorthandModuleSymbol: aliasedSymbol };
+            }
+
+            symbol = aliasedSymbol;
+        }
+    }
+
     function sourceFileHasName(sourceFile: SourceFile, name: string): boolean {
         return getNameTable(sourceFile).get(name) !== undefined;
     }
@@ -157,29 +181,30 @@ namespace ts.FindAllReferences {
     }
 
     function getAliasSymbolForPropertyNameSymbol(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol | undefined {
-        if (symbol.flags & SymbolFlags.Alias) {
-            // Default import get alias
-            const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause);
-            if (defaultImport) {
-                return typeChecker.getAliasedSymbol(symbol);
-            }
+        if (!(symbol.flags & SymbolFlags.Alias)) {
+            return undefined;
+        }
 
-            const importOrExportSpecifier = <ImportOrExportSpecifier>forEach(symbol.declarations,
-                declaration => (declaration.kind === SyntaxKind.ImportSpecifier ||
-                    declaration.kind === SyntaxKind.ExportSpecifier) ? declaration : undefined);
-            if (importOrExportSpecifier &&
-                // export { a }
-                (!importOrExportSpecifier.propertyName ||
-                    // export {a as class } where a is location
-                    importOrExportSpecifier.propertyName === location)) {
-                // If Import specifier -> get alias
-                // else Export specifier -> get local target
-                return importOrExportSpecifier.kind === SyntaxKind.ImportSpecifier ?
-                    typeChecker.getAliasedSymbol(symbol) :
-                    typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier);
-            }
+        // Default import get alias
+        const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause);
+        if (defaultImport) {
+            return typeChecker.getAliasedSymbol(symbol);
+        }
+
+        const importOrExportSpecifier = <ImportOrExportSpecifier>forEach(symbol.declarations,
+            declaration => (declaration.kind === SyntaxKind.ImportSpecifier ||
+                declaration.kind === SyntaxKind.ExportSpecifier) ? declaration : undefined);
+        if (importOrExportSpecifier &&
+            // export { a }
+            (!importOrExportSpecifier.propertyName ||
+                // export {a as class } where a is location
+                importOrExportSpecifier.propertyName === location)) {
+            // If Import specifier -> get alias
+            // else Export specifier -> get local target
+            return importOrExportSpecifier.kind === SyntaxKind.ImportSpecifier ?
+                typeChecker.getAliasedSymbol(symbol) :
+                typeChecker.getExportSpecifierLocalTargetSymbol(importOrExportSpecifier);
         }
-        return undefined;
     }
 
     function followAliasIfNecessary(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol {
@@ -1022,9 +1047,9 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean, aliasSymbol?: Symbol): Symbol[] {
+    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean): Symbol[] {
         // The search set contains at least the current symbol
-        let result = [symbol];
+        const result = [symbol];
 
         // If the location is name of property symbol from object literal destructuring pattern
         // Search the property symbol
@@ -1037,10 +1062,6 @@ namespace ts.FindAllReferences {
             }
         }
 
-        if (aliasSymbol) {
-            result = result.concat(populateSearchSymbolSet(aliasSymbol, location, typeChecker, implementations));
-        }
-
         // If the location is in a context sensitive location (i.e. in an object literal) try
         // to get a contextual type for it, and add the property symbol from the contextual
         // type to the search set
@@ -1072,7 +1093,7 @@ namespace ts.FindAllReferences {
         // Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members
         if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.Parameter &&
             isParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration)) {
-            result = result.concat(typeChecker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
+            addRange(result, typeChecker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
         }
 
         // If this is symbol of binding element without propertyName declaration in Object binding pattern
@@ -1447,4 +1468,8 @@ namespace ts.FindAllReferences {
 
         return false;
     }
+
+    function isImportDefaultSymbol(symbol: Symbol): boolean {
+        return symbol.declarations[0].kind === SyntaxKind.ImportClause;
+    }
 }
diff --git a/src/services/goToImplementation.ts b/src/services/goToImplementation.ts
index 123d29630ad..9135e1fe0f0 100644
--- a/src/services/goToImplementation.ts
+++ b/src/services/goToImplementation.ts
@@ -17,7 +17,7 @@ namespace ts.GoToImplementation {
         else {
             // Perform "Find all References" and retrieve only those that are implementations
             const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken,
-                node, sourceFiles, /*findInStrings*/false, /*findInComments*/false, /*implementations*/true);
+                node, sourceFiles, /*findInStrings*/false, /*findInComments*/false, /*isForRename*/false, /*implementations*/true);
             const result = flatMap(referencedSymbols, symbol =>
                 map(symbol.references, ({ textSpan, fileName }) => ({ textSpan, fileName })));
 
diff --git a/src/services/services.ts b/src/services/services.ts
index cb38b1d500e..00a8c9a9f2e 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1406,25 +1406,25 @@ namespace ts {
         }
 
         function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[] {
-            const referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments);
+            const referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments, /*isForRename*/true);
             return FindAllReferences.convertReferences(referencedSymbols);
         }
 
         function getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
-            const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false);
+            const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false);
             return FindAllReferences.convertReferences(referencedSymbols);
         }
 
         function findReferences(fileName: string, position: number): ReferencedSymbol[] {
-            const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false);
+            const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false);
 
             // Only include referenced symbols that have a valid definition.
             return filter(referencedSymbols, rs => !!rs.definition);
         }
 
-        function findReferencedSymbols(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[] {
+        function findReferencedSymbols(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, isForRename: boolean): ReferencedSymbol[] {
             synchronizeHostData();
-            return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, findInStrings, findInComments);
+            return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, findInStrings, findInComments, isForRename);
         }
 
         /// NavigateTo
diff --git a/tests/cases/fourslash/renameDefaultImport.ts b/tests/cases/fourslash/renameDefaultImport.ts
index 8d9b65d78d6..ff297ffa147 100644
--- a/tests/cases/fourslash/renameDefaultImport.ts
+++ b/tests/cases/fourslash/renameDefaultImport.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
 // @Filename: B.ts
-////export default class [|B|] {
+////export default class /*1*/[|B|] {
 ////    test() {
 ////    }
 ////}
@@ -11,4 +11,17 @@
 ////let b = new [|B|]();
 ////b.test();
 
-verify.rangesAreRenameLocations();
+goTo.marker("1");
+verify.occurrencesAtPositionCount(1);
+
+const [C, B0, B1] = test.ranges();
+verify.rangesReferenceEachOther();
+
+goTo.rangeStart(C);
+verify.renameLocations(false, false, [C, B0, B1]);
+
+const rangesInB = [B0, B1];
+for (const r of rangesInB) {
+    goTo.rangeStart(r);
+    verify.renameLocations(false, false, rangesInB);
+}
diff --git a/tests/cases/fourslash/renameDefaultImportDifferentName.ts b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
index aec699aadda..be968c9b883 100644
--- a/tests/cases/fourslash/renameDefaultImportDifferentName.ts
+++ b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts' />
 
 // @Filename: B.ts
-////export default class /*1*/C {
+////export default class /*1*/[|C|] {
 ////    test() {
 ////    }
 ////}
@@ -14,4 +14,14 @@
 goTo.marker("1");
 verify.occurrencesAtPositionCount(1);
 
-verify.rangesAreRenameLocations();
+const [C, B0, B1] = test.ranges();
+verify.rangesReferenceEachOther();
+
+goTo.rangeStart(C);
+verify.renameLocations(false, false, [C, B0, B1]);
+
+const rangesInB = [B0, B1];
+for (const r of rangesInB) {
+    goTo.rangeStart(r);
+    verify.renameLocations(false, false, rangesInB);
+}
diff --git a/tests/cases/fourslash/renameImportAndExport.ts b/tests/cases/fourslash/renameImportAndExport.ts
index fe8bce4b208..4545277c564 100644
--- a/tests/cases/fourslash/renameImportAndExport.ts
+++ b/tests/cases/fourslash/renameImportAndExport.ts
@@ -3,4 +3,6 @@
 ////import [|a|] from "module";
 ////export { [|a|] };
 
-verify.rangesAreRenameLocations();
+const [r0, r1] = test.ranges();
+verify.referencesOf(r1, [r0, r1]);
+//verify.rangesAreRenameLocations();

From b48a2811f67b66a14cd4584999a7d7ab2e723b56 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 13:03:16 -0800
Subject: [PATCH 108/159] Update baselines

---
 tests/baselines/reference/mappedTypes1.js    | 2 +-
 tests/baselines/reference/mappedTypes1.types | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/baselines/reference/mappedTypes1.js b/tests/baselines/reference/mappedTypes1.js
index 1998ad5ab6b..4dd8f172179 100644
--- a/tests/baselines/reference/mappedTypes1.js
+++ b/tests/baselines/reference/mappedTypes1.js
@@ -139,9 +139,9 @@ declare let x2: string;
 declare let x3: number;
 declare let x4: {
     toString: void;
-    valueOf: void;
     toFixed: void;
     toExponential: void;
     toPrecision: void;
+    valueOf: void;
     toLocaleString: void;
 };
diff --git a/tests/baselines/reference/mappedTypes1.types b/tests/baselines/reference/mappedTypes1.types
index 35d13143bab..a9a7f53a899 100644
--- a/tests/baselines/reference/mappedTypes1.types
+++ b/tests/baselines/reference/mappedTypes1.types
@@ -165,7 +165,7 @@ let x3 = f3();
 >f3 : <T1 extends number>() => { [P in keyof T1]: void; }
 
 let x4 = f4();
->x4 : { toString: void; valueOf: void; toFixed: void; toExponential: void; toPrecision: void; toLocaleString: void; }
->f4() : { toString: void; valueOf: void; toFixed: void; toExponential: void; toPrecision: void; toLocaleString: void; }
+>x4 : { toString: void; toFixed: void; toExponential: void; toPrecision: void; valueOf: void; toLocaleString: void; }
+>f4() : { toString: void; toFixed: void; toExponential: void; toPrecision: void; valueOf: void; toLocaleString: void; }
 >f4 : <T1 extends Number>() => { [P in keyof T1]: void; }
 

From 20249e5c4a66e5abef595c52e87be5b1eabff468 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Tue, 24 Jan 2017 13:42:05 -0800
Subject: [PATCH 109/159] More exhaustive needsDotDotForPropertyAccess

---
 src/compiler/emitter.ts                       |  6 ++-
 src/compiler/utilities.ts                     | 42 +++++++++++++++++--
 .../propertyAccessNumericLiterals.es6.js      | 14 +++++++
 .../propertyAccessNumericLiterals.es6.symbols | 21 ++++++++++
 .../propertyAccessNumericLiterals.es6.types   | 31 ++++++++++++++
 .../propertyAccessNumericLiterals.js          | 15 +++++++
 .../propertyAccessNumericLiterals.symbols     | 25 +++++++++++
 .../propertyAccessNumericLiterals.types       | 37 ++++++++++++++++
 .../propertyAccessNumericLiterals.es6.ts      |  6 +++
 .../propertyAccessNumericLiterals.ts          |  7 ++++
 10 files changed, 199 insertions(+), 5 deletions(-)
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.es6.js
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.es6.types
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.js
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.symbols
 create mode 100644 tests/baselines/reference/propertyAccessNumericLiterals.types
 create mode 100644 tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts
 create mode 100644 tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index cc006a06637..27285a4c2dc 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1054,9 +1054,11 @@ namespace ts {
         // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal
         function needsDotDotForPropertyAccess(expression: Expression) {
             if (expression.kind === SyntaxKind.NumericLiteral) {
-                // check if numeric literal was originally written with a dot
+                // check if numeric literal is a decimal literal that was originally written with a dot
                 const text = getLiteralTextOfNode(<LiteralExpression>expression);
-                return text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
+                return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None
+                    && !(<LiteralExpression>expression).isOctalLiteral
+                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
             }
             else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
                 // check if constant enum value is integer
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b7cc0f0de6d..b1d2ba0854c 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -341,16 +341,52 @@ namespace ts {
     }
 
     export function isBinaryOrOctalIntegerLiteral(node: LiteralLikeNode, text: string) {
-        if (node.kind === SyntaxKind.NumericLiteral && text.length > 1) {
+        return node.kind === SyntaxKind.NumericLiteral
+            && (getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.BinaryOrOctal) & NumericLiteralFlags.BinaryOrOctal) !== 0;
+    }
+
+    export const enum NumericLiteralFlags {
+        None = 0,
+        Hexadecimal = 1 << 0,
+        Binary = 1 << 1,
+        Octal = 1 << 2,
+        Scientific = 1 << 3,
+
+        BinaryOrOctal = Binary | Octal,
+        BinaryOrOctalOrHexadecimal = BinaryOrOctal | Hexadecimal,
+        All = Hexadecimal | Binary | Octal | Scientific,
+    }
+
+    /**
+     * Scans a numeric literal string to determine the form of the number.
+     * @param text Numeric literal text
+     * @param hint If `Scientific` or `All` is specified, performs a more expensive check to scan for scientific notation.
+     */
+    export function getNumericLiteralFlags(text: string, hint?: NumericLiteralFlags) {
+        if (text.length > 1) {
             switch (text.charCodeAt(1)) {
                 case CharacterCodes.b:
                 case CharacterCodes.B:
+                    return NumericLiteralFlags.Binary;
                 case CharacterCodes.o:
                 case CharacterCodes.O:
-                    return true;
+                    return NumericLiteralFlags.Octal;
+                case CharacterCodes.x:
+                case CharacterCodes.X:
+                    return NumericLiteralFlags.Hexadecimal;
+            }
+
+            if (hint & NumericLiteralFlags.Scientific) {
+                for (let i = text.length - 1; i >= 0; i--) {
+                    switch (text.charCodeAt(i)) {
+                        case CharacterCodes.e:
+                        case CharacterCodes.E:
+                            return NumericLiteralFlags.Scientific;
+                    }
+                }
             }
         }
-        return false;
+        return NumericLiteralFlags.None;
     }
 
     function getQuotedEscapedLiteralText(leftQuote: string, text: string, rightQuote: string) {
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.es6.js b/tests/baselines/reference/propertyAccessNumericLiterals.es6.js
new file mode 100644
index 00000000000..66ac4178155
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.es6.js
@@ -0,0 +1,14 @@
+//// [propertyAccessNumericLiterals.es6.ts]
+0xffffffff.toString();
+0o01234.toString();
+0b01101101.toString();
+1234..toString();
+1e0.toString();
+
+
+//// [propertyAccessNumericLiterals.es6.js]
+0xffffffff.toString();
+0o01234.toString();
+0b01101101.toString();
+1234..toString();
+1e0.toString();
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols b/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
new file mode 100644
index 00000000000..dc0be21d84f
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.es6.symbols
@@ -0,0 +1,21 @@
+=== tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts ===
+0xffffffff.toString();
+>0xffffffff.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+
+0o01234.toString();
+>0o01234.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+
+0b01101101.toString();
+>0b01101101.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+
+1234..toString();
+>1234..toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+
+1e0.toString();
+>1e0.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --))
+
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.es6.types b/tests/baselines/reference/propertyAccessNumericLiterals.es6.types
new file mode 100644
index 00000000000..9d32cc5b6e8
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.es6.types
@@ -0,0 +1,31 @@
+=== tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts ===
+0xffffffff.toString();
+>0xffffffff.toString() : string
+>0xffffffff.toString : (radix?: number) => string
+>0xffffffff : 4294967295
+>toString : (radix?: number) => string
+
+0o01234.toString();
+>0o01234.toString() : string
+>0o01234.toString : (radix?: number) => string
+>0o01234 : 668
+>toString : (radix?: number) => string
+
+0b01101101.toString();
+>0b01101101.toString() : string
+>0b01101101.toString : (radix?: number) => string
+>0b01101101 : 109
+>toString : (radix?: number) => string
+
+1234..toString();
+>1234..toString() : string
+>1234..toString : (radix?: number) => string
+>1234. : 1234
+>toString : (radix?: number) => string
+
+1e0.toString();
+>1e0.toString() : string
+>1e0.toString : (radix?: number) => string
+>1e0 : 1
+>toString : (radix?: number) => string
+
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.js b/tests/baselines/reference/propertyAccessNumericLiterals.js
new file mode 100644
index 00000000000..1a7eb6c0a21
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.js
@@ -0,0 +1,15 @@
+//// [propertyAccessNumericLiterals.ts]
+0xffffffff.toString();
+0o01234.toString();
+0b01101101.toString();
+1234..toString();
+1e0.toString();
+000.toString();
+
+//// [propertyAccessNumericLiterals.js]
+0xffffffff.toString();
+668..toString();
+109..toString();
+1234..toString();
+1e0.toString();
+000.toString();
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.symbols b/tests/baselines/reference/propertyAccessNumericLiterals.symbols
new file mode 100644
index 00000000000..5be13615e90
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.symbols
@@ -0,0 +1,25 @@
+=== tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts ===
+0xffffffff.toString();
+>0xffffffff.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
+0o01234.toString();
+>0o01234.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
+0b01101101.toString();
+>0b01101101.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
+1234..toString();
+>1234..toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
+1e0.toString();
+>1e0.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
+000.toString();
+>000.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/propertyAccessNumericLiterals.types b/tests/baselines/reference/propertyAccessNumericLiterals.types
new file mode 100644
index 00000000000..a2567ff2537
--- /dev/null
+++ b/tests/baselines/reference/propertyAccessNumericLiterals.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts ===
+0xffffffff.toString();
+>0xffffffff.toString() : string
+>0xffffffff.toString : (radix?: number) => string
+>0xffffffff : 4294967295
+>toString : (radix?: number) => string
+
+0o01234.toString();
+>0o01234.toString() : string
+>0o01234.toString : (radix?: number) => string
+>0o01234 : 668
+>toString : (radix?: number) => string
+
+0b01101101.toString();
+>0b01101101.toString() : string
+>0b01101101.toString : (radix?: number) => string
+>0b01101101 : 109
+>toString : (radix?: number) => string
+
+1234..toString();
+>1234..toString() : string
+>1234..toString : (radix?: number) => string
+>1234. : 1234
+>toString : (radix?: number) => string
+
+1e0.toString();
+>1e0.toString() : string
+>1e0.toString : (radix?: number) => string
+>1e0 : 1
+>toString : (radix?: number) => string
+
+000.toString();
+>000.toString() : string
+>000.toString : (radix?: number) => string
+>000 : 0
+>toString : (radix?: number) => string
+
diff --git a/tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts b/tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts
new file mode 100644
index 00000000000..81e39965a6a
--- /dev/null
+++ b/tests/cases/conformance/es6/propertyAccess/propertyAccessNumericLiterals.es6.ts
@@ -0,0 +1,6 @@
+// @target: es6
+0xffffffff.toString();
+0o01234.toString();
+0b01101101.toString();
+1234..toString();
+1e0.toString();
diff --git a/tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts b/tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts
new file mode 100644
index 00000000000..318b05fc0b5
--- /dev/null
+++ b/tests/cases/conformance/expressions/propertyAccess/propertyAccessNumericLiterals.ts
@@ -0,0 +1,7 @@
+// @target: es3
+0xffffffff.toString();
+0o01234.toString();
+0b01101101.toString();
+1234..toString();
+1e0.toString();
+000.toString();
\ No newline at end of file

From a478bfddd2233d3579a2b037fc0df32807cb0ebe Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 13:44:36 -0800
Subject: [PATCH 110/159] Simplify code in 'rename'

---
 src/services/rename.ts | 172 ++++++++++++++++++++---------------------
 1 file changed, 84 insertions(+), 88 deletions(-)

diff --git a/src/services/rename.ts b/src/services/rename.ts
index 6f28e505f79..afb16618b03 100644
--- a/src/services/rename.ts
+++ b/src/services/rename.ts
@@ -1,98 +1,94 @@
 /* @internal */
 namespace ts.Rename {
     export function getRenameInfo(typeChecker: TypeChecker, defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string, sourceFile: SourceFile, position: number): RenameInfo {
-        const canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
-
         const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
+        const renameInfo = node && nodeIsEligibleForRename(node)
+            ? getRenameInfoForNode(node, typeChecker, sourceFile, getIsDefinedInLibraryFile(defaultLibFileName, getCanonicalFileName))
+            : undefined;
+        return renameInfo || getRenameInfoError(Diagnostics.You_cannot_rename_this_element);
+    }
 
-        if (node) {
-            if (node.kind === SyntaxKind.Identifier ||
-                node.kind === SyntaxKind.StringLiteral ||
-                isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
-                isThis(node)) {
-                const symbol = typeChecker.getSymbolAtLocation(node);
-
-                // Only allow a symbol to be renamed if it actually has at least one declaration.
-                if (symbol) {
-                    const declarations = symbol.getDeclarations();
-                    if (declarations && declarations.length > 0) {
-                        // Disallow rename for elements that are defined in the standard TypeScript library.
-                        if (forEach(declarations, isDefinedInLibraryFile)) {
-                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
-                        }
-
-                        const displayName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
-                        const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
-                        if (kind) {
-                            return {
-                                canRename: true,
-                                kind,
-                                displayName,
-                                localizedErrorMessage: undefined,
-                                fullDisplayName: typeChecker.getFullyQualifiedName(symbol),
-                                kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
-                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
-                            };
-                        }
-                    }
-                }
-                else if (node.kind === SyntaxKind.StringLiteral) {
-                    const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
-                    if (type) {
-                        if (isDefinedInLibraryFile(node)) {
-                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
-                        }
-                        else {
-                            const displayName = stripQuotes(type.text);
-                            return {
-                                canRename: true,
-                                kind: ScriptElementKind.variableElement,
-                                displayName,
-                                localizedErrorMessage: undefined,
-                                fullDisplayName: displayName,
-                                kindModifiers: ScriptElementKindModifier.none,
-                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
-                            };
-                        }
-                    }
-                }
-            }
+    function getIsDefinedInLibraryFile(defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string): (declaration: Node) => boolean {
+        if (!defaultLibFileName) {
+            return () => false;
         }
 
-        return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element));
-
-        function getRenameInfoError(localizedErrorMessage: string): RenameInfo {
-            return {
-                canRename: false,
-                localizedErrorMessage: localizedErrorMessage,
-                displayName: undefined,
-                fullDisplayName: undefined,
-                kind: undefined,
-                kindModifiers: undefined,
-                triggerSpan: undefined
-            };
-        }
-
-        function isDefinedInLibraryFile(declaration: Node) {
-            if (defaultLibFileName) {
-                const sourceFile = declaration.getSourceFile();
-                const canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
-                if (canonicalName === canonicalDefaultLibName) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        function createTriggerSpanForNode(node: Node, sourceFile: SourceFile) {
-            let start = node.getStart(sourceFile);
-            let width = node.getWidth(sourceFile);
-            if (node.kind === SyntaxKind.StringLiteral) {
-                // Exclude the quotes
-                start += 1;
-                width -= 2;
-            }
-            return createTextSpan(start, width);
+        const canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
+        return declaration => {
+            const sourceFile = declaration.getSourceFile();
+            const canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
+            return canonicalName === canonicalDefaultLibName;
         }
     }
+
+    function getRenameInfoForNode(node: Node, typeChecker: TypeChecker, sourceFile: SourceFile, isDefinedInLibraryFile: (declaration: Node) => boolean): RenameInfo | undefined {
+        const symbol = typeChecker.getSymbolAtLocation(node);
+
+        // Only allow a symbol to be renamed if it actually has at least one declaration.
+        if (symbol) {
+            const declarations = symbol.getDeclarations();
+            if (declarations && declarations.length > 0) {
+                // Disallow rename for elements that are defined in the standard TypeScript library.
+                if (some(declarations, isDefinedInLibraryFile)) {
+                    return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library);
+                }
+
+                const displayName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
+                const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
+                return kind ? getRenameInfoSuccess(displayName, typeChecker.getFullyQualifiedName(symbol), kind, SymbolDisplay.getSymbolModifiers(symbol), node, sourceFile) : undefined;
+            }
+        }
+        else if (node.kind === SyntaxKind.StringLiteral) {
+            const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
+            if (type) {
+                if (isDefinedInLibraryFile(node)) {
+                    return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library);
+                }
+
+                const displayName = stripQuotes(type.text);
+                return getRenameInfoSuccess(displayName, displayName, ScriptElementKind.variableElement, ScriptElementKindModifier.none, node, sourceFile);
+            }
+        }
+    }
+
+    function getRenameInfoSuccess(displayName: string, fullDisplayName: string, kind: string, kindModifiers: string, node: Node, sourceFile: SourceFile): RenameInfo {
+        return {
+            canRename: true,
+            kind,
+            displayName,
+            localizedErrorMessage: undefined,
+            fullDisplayName,
+            kindModifiers,
+            triggerSpan: createTriggerSpanForNode(node, sourceFile)
+        };
+    }
+
+    function getRenameInfoError(diagnostic: DiagnosticMessage): RenameInfo {
+        return {
+            canRename: false,
+            localizedErrorMessage: getLocaleSpecificMessage(diagnostic),
+            displayName: undefined,
+            fullDisplayName: undefined,
+            kind: undefined,
+            kindModifiers: undefined,
+            triggerSpan: undefined
+        };
+    }
+
+    function createTriggerSpanForNode(node: Node, sourceFile: SourceFile) {
+        let start = node.getStart(sourceFile);
+        let width = node.getWidth(sourceFile);
+        if (node.kind === SyntaxKind.StringLiteral) {
+            // Exclude the quotes
+            start += 1;
+            width -= 2;
+        }
+        return createTextSpan(start, width);
+    }
+
+    function nodeIsEligibleForRename(node: Node) {
+        return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral ||
+            isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+            isThis(node);
+    }
 }

From 50442b5a23148a9dd818e716748b48be00776a8a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 13:57:42 -0800
Subject: [PATCH 111/159] Undo change to test

---
 tests/cases/fourslash/renameImportAndExport.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tests/cases/fourslash/renameImportAndExport.ts b/tests/cases/fourslash/renameImportAndExport.ts
index 4545277c564..fe8bce4b208 100644
--- a/tests/cases/fourslash/renameImportAndExport.ts
+++ b/tests/cases/fourslash/renameImportAndExport.ts
@@ -3,6 +3,4 @@
 ////import [|a|] from "module";
 ////export { [|a|] };
 
-const [r0, r1] = test.ranges();
-verify.referencesOf(r1, [r0, r1]);
-//verify.rangesAreRenameLocations();
+verify.rangesAreRenameLocations();

From 33b8677cb52eb54a3d4d8365fb3e6b7eba2c0dec Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 24 Jan 2017 14:32:39 -0800
Subject: [PATCH 112/159] Change "getIsDefinedInLibraryFile" back to just
 "isDefinedInLibraryFile"

---
 src/services/rename.ts | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/services/rename.ts b/src/services/rename.ts
index afb16618b03..2e9396888ef 100644
--- a/src/services/rename.ts
+++ b/src/services/rename.ts
@@ -1,23 +1,21 @@
 /* @internal */
 namespace ts.Rename {
     export function getRenameInfo(typeChecker: TypeChecker, defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string, sourceFile: SourceFile, position: number): RenameInfo {
+        const getCanonicalDefaultLibName = memoize(() => getCanonicalFileName(ts.normalizePath(defaultLibFileName)));
         const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
         const renameInfo = node && nodeIsEligibleForRename(node)
-            ? getRenameInfoForNode(node, typeChecker, sourceFile, getIsDefinedInLibraryFile(defaultLibFileName, getCanonicalFileName))
+            ? getRenameInfoForNode(node, typeChecker, sourceFile, isDefinedInLibraryFile)
             : undefined;
         return renameInfo || getRenameInfoError(Diagnostics.You_cannot_rename_this_element);
-    }
 
-    function getIsDefinedInLibraryFile(defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string): (declaration: Node) => boolean {
-        if (!defaultLibFileName) {
-            return () => false;
-        }
+        function isDefinedInLibraryFile(declaration: Node) {
+            if (!defaultLibFileName) {
+                return false;
+            }
 
-        const canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
-        return declaration => {
             const sourceFile = declaration.getSourceFile();
             const canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
-            return canonicalName === canonicalDefaultLibName;
+            return canonicalName === getCanonicalDefaultLibName();
         }
     }
 

From 9be46006e60c6ce218086dec27534c8e17651816 Mon Sep 17 00:00:00 2001
From: Anatoly Ressin <artazor@gmail.com>
Date: Wed, 25 Jan 2017 15:41:46 +0200
Subject: [PATCH 113/159] fixes #13674

---
 tests/webTestServer.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/webTestServer.ts b/tests/webTestServer.ts
index 67bbce2a472..abfd71a8fff 100644
--- a/tests/webTestServer.ts
+++ b/tests/webTestServer.ts
@@ -315,7 +315,6 @@ if (browser === "chrome") {
     let defaultChromePath = "";
     switch (os.platform()) {
         case "win32":
-        case "win64":
             defaultChromePath = "C:/Program Files (x86)/Google/Chrome/Application/chrome.exe";
             break;
         case "darwin":

From 128b84d1db7359119fa211c3a222d43f5fb99a8b Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 25 Jan 2017 09:13:00 -0800
Subject: [PATCH 114/159] Add "workers" option in gulpfile.

This allows e.g. `gulp runtests-parallel --w 3`.
---
 Gulpfile.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/Gulpfile.ts b/Gulpfile.ts
index bf5a074ef06..4f205bfb0ff 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -50,7 +50,8 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
         r: "reporter",
         color: "colors",
         f: "files",
-        file: "files"
+        file: "files",
+        w: "workers",
     },
     default: {
         soft: false,
@@ -63,6 +64,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
         reporter: process.env.reporter || process.env.r,
         lint: process.env.lint || true,
         files: process.env.f || process.env.file || process.env.files || "",
+        workers: process.env.workerCount || os.cpus().length,
     }
 });
 
@@ -604,7 +606,7 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
             } while (fs.existsSync(taskConfigsFolder));
             fs.mkdirSync(taskConfigsFolder);
 
-            workerCount = process.env.workerCount || os.cpus().length;
+            workerCount = cmdLineOptions["workers"];
         }
 
         if (tests || light || taskConfigsFolder) {
@@ -1017,7 +1019,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
             cb();
         }, (cb) => {
             files = files.filter(file =>  fileMatcher.test(file.path)).sort((filea, fileb) => filea.stat.size - fileb.stat.size);
-            const workerCount = (process.env.workerCount && +process.env.workerCount) || os.cpus().length;
+            const workerCount = cmdLineOptions["workers"];
             for (let i = 0; i < workerCount; i++) {
                 spawnLintWorker(files, finished);
             }

From abc30b26c75247d839d2a2ecf5ee2b80ff5864ac Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Wed, 25 Jan 2017 09:53:34 -0800
Subject: [PATCH 115/159] handle cases when body of for-of statement is
 expanded after loop conversion (#13677)

---
 src/compiler/transformers/es2015.ts           |  2 +-
 .../nestedLoopWithOnlyInnerLetCaptured.js     | 18 +++++++++++++++++
 ...nestedLoopWithOnlyInnerLetCaptured.symbols | 15 ++++++++++++++
 .../nestedLoopWithOnlyInnerLetCaptured.types  | 20 +++++++++++++++++++
 .../nestedLoopWithOnlyInnerLetCaptured.ts     |  6 ++++++
 5 files changed, 60 insertions(+), 1 deletion(-)
 create mode 100644 tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.js
 create mode 100644 tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.symbols
 create mode 100644 tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.types
 create mode 100644 tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts

diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index d1dab8eeb7a..3b8b4524aab 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -2316,7 +2316,7 @@ namespace ts {
                 addRange(statements, convertedLoopBodyStatements);
             }
             else {
-                const statement = visitNode(node.statement, visitor, isStatement);
+                const statement = visitNode(node.statement, visitor, isStatement, /*optional*/ false, liftToBlock);
                 if (isBlock(statement)) {
                     addRange(statements, statement.statements);
                     bodyLocation = statement;
diff --git a/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.js b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.js
new file mode 100644
index 00000000000..ee17bb53eec
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.js
@@ -0,0 +1,18 @@
+//// [nestedLoopWithOnlyInnerLetCaptured.ts]
+declare let doSomething;
+
+for (let a1 of [])
+    for (let a2 of a1.someArray)
+        doSomething(() => a2);
+
+//// [nestedLoopWithOnlyInnerLetCaptured.js]
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    var a1 = _a[_i];
+    var _loop_1 = function (a2) {
+        doSomething(function () { return a2; });
+    };
+    for (var _b = 0, _c = a1.someArray; _b < _c.length; _b++) {
+        var a2 = _c[_b];
+        _loop_1(a2);
+    }
+}
diff --git a/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.symbols b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.symbols
new file mode 100644
index 00000000000..f134dcbffa9
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.symbols
@@ -0,0 +1,15 @@
+=== tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts ===
+declare let doSomething;
+>doSomething : Symbol(doSomething, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 0, 11))
+
+for (let a1 of [])
+>a1 : Symbol(a1, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 2, 8))
+
+    for (let a2 of a1.someArray)
+>a2 : Symbol(a2, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 3, 12))
+>a1 : Symbol(a1, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 2, 8))
+
+        doSomething(() => a2);
+>doSomething : Symbol(doSomething, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 0, 11))
+>a2 : Symbol(a2, Decl(nestedLoopWithOnlyInnerLetCaptured.ts, 3, 12))
+
diff --git a/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.types b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.types
new file mode 100644
index 00000000000..6be9dbf6abf
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopWithOnlyInnerLetCaptured.types
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts ===
+declare let doSomething;
+>doSomething : any
+
+for (let a1 of [])
+>a1 : any
+>[] : undefined[]
+
+    for (let a2 of a1.someArray)
+>a2 : any
+>a1.someArray : any
+>a1 : any
+>someArray : any
+
+        doSomething(() => a2);
+>doSomething(() => a2) : any
+>doSomething : any
+>() => a2 : () => any
+>a2 : any
+
diff --git a/tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts b/tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts
new file mode 100644
index 00000000000..210465b13da
--- /dev/null
+++ b/tests/cases/compiler/nestedLoopWithOnlyInnerLetCaptured.ts
@@ -0,0 +1,6 @@
+// @target: es5
+declare let doSomething;
+
+for (let a1 of [])
+    for (let a2 of a1.someArray)
+        doSomething(() => a2);
\ No newline at end of file

From 76b1e95c3d89fa2ca762eda75c9bd182612ee85a Mon Sep 17 00:00:00 2001
From: Ryan Cavanaugh <RyanCavanaugh@users.noreply.github.com>
Date: Wed, 25 Jan 2017 10:40:59 -0800
Subject: [PATCH 116/159] Always call `checkExpression` on JSX attribute values

Fixes #13676
---
 src/compiler/checker.ts                       | 19 ++---
 .../baselines/reference/reactImportDropped.js | 48 ++++++++++++
 .../reference/reactImportDropped.symbols      | 65 ++++++++++++++++
 .../reference/reactImportDropped.types        | 74 +++++++++++++++++++
 tests/cases/compiler/reactImportDropped.ts    | 42 +++++++++++
 5 files changed, 239 insertions(+), 9 deletions(-)
 create mode 100644 tests/baselines/reference/reactImportDropped.js
 create mode 100644 tests/baselines/reference/reactImportDropped.symbols
 create mode 100644 tests/baselines/reference/reactImportDropped.types
 create mode 100644 tests/cases/compiler/reactImportDropped.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a09b63d46fd..7c8a0b7337f 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -11879,6 +11879,16 @@ namespace ts {
         function checkJsxAttribute(node: JsxAttribute, elementAttributesType: Type, nameTable: Map<boolean>) {
             let correspondingPropType: Type = undefined;
 
+            // We need to unconditionally get the expression type
+            let exprType: Type;
+            if (node.initializer) {
+                exprType = checkExpression(node.initializer);
+            }
+            else {
+                // <Elem attr /> is sugar for <Elem attr={true} />
+                exprType = booleanType;
+            }
+
             // Look up the corresponding property for this attribute
             if (elementAttributesType === emptyObjectType && isUnhyphenatedJsxName(node.name.text)) {
                 // If there is no 'props' property, you may not have non-"data-" attributes
@@ -11902,15 +11912,6 @@ namespace ts {
                 }
             }
 
-            let exprType: Type;
-            if (node.initializer) {
-                exprType = checkExpression(node.initializer);
-            }
-            else {
-                // <Elem attr /> is sugar for <Elem attr={true} />
-                exprType = booleanType;
-            }
-
             if (correspondingPropType) {
                 checkTypeAssignableTo(exprType, correspondingPropType, node);
             }
diff --git a/tests/baselines/reference/reactImportDropped.js b/tests/baselines/reference/reactImportDropped.js
new file mode 100644
index 00000000000..7ada76b42f4
--- /dev/null
+++ b/tests/baselines/reference/reactImportDropped.js
@@ -0,0 +1,48 @@
+//// [tests/cases/compiler/reactImportDropped.ts] ////
+
+//// [react.d.ts]
+
+export = React;
+export as namespace React;
+
+declare namespace React {
+
+    function createClass(spec: any): ClassicComponentClass;
+
+    interface ClassicComponentClass {
+        new (props?: any): ClassicComponentClass;
+    }
+}
+
+declare global {
+    namespace JSX {
+        interface ElementAttributesProperty { }
+    }
+}
+
+
+//// [TabBar.js]
+export default React.createClass({
+  render() {
+    return (
+      null
+    );
+  }
+});
+
+//// [NavigationView.js]
+import TabBar from '../../components/TabBar';
+import {layout} from '../../utils/theme'; // <- DO NOT DROP this import
+const x = <TabBar height={layout.footerHeight} />;
+
+
+//// [TabBar.js]
+export default React.createClass({
+    render() {
+        return (null);
+    }
+});
+//// [NavigationView.js]
+import TabBar from '../../components/TabBar';
+import { layout } from '../../utils/theme'; // <- DO NOT DROP this import
+const x = React.createElement(TabBar, { height: layout.footerHeight });
diff --git a/tests/baselines/reference/reactImportDropped.symbols b/tests/baselines/reference/reactImportDropped.symbols
new file mode 100644
index 00000000000..d7374df044e
--- /dev/null
+++ b/tests/baselines/reference/reactImportDropped.symbols
@@ -0,0 +1,65 @@
+=== tests/cases/compiler/react.d.ts ===
+
+export = React;
+>React : Symbol(React, Decl(react.d.ts, 2, 26))
+
+export as namespace React;
+>React : Symbol(React, Decl(react.d.ts, 1, 15))
+
+declare namespace React {
+>React : Symbol(React, Decl(react.d.ts, 2, 26))
+
+    function createClass(spec: any): ClassicComponentClass;
+>createClass : Symbol(createClass, Decl(react.d.ts, 4, 25))
+>spec : Symbol(spec, Decl(react.d.ts, 6, 25))
+>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59))
+
+    interface ClassicComponentClass {
+>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59))
+
+        new (props?: any): ClassicComponentClass;
+>props : Symbol(props, Decl(react.d.ts, 9, 13))
+>ClassicComponentClass : Symbol(ClassicComponentClass, Decl(react.d.ts, 6, 59))
+    }
+}
+
+declare global {
+>global : Symbol(global, Decl(react.d.ts, 11, 1))
+
+    namespace JSX {
+>JSX : Symbol(JSX, Decl(react.d.ts, 13, 16))
+
+        interface ElementAttributesProperty { }
+>ElementAttributesProperty : Symbol(ElementAttributesProperty, Decl(react.d.ts, 14, 19))
+    }
+}
+
+
+=== tests/cases/compiler/src/components/TabBar.js ===
+export default React.createClass({
+>React.createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25))
+>React : Symbol(React, Decl(react.d.ts, 1, 15))
+>createClass : Symbol(React.createClass, Decl(react.d.ts, 4, 25))
+
+  render() {
+>render : Symbol(render, Decl(TabBar.js, 0, 34))
+
+    return (
+      null
+    );
+  }
+});
+
+=== tests/cases/compiler/src/modules/navigation/NavigationView.js ===
+import TabBar from '../../components/TabBar';
+>TabBar : Symbol(TabBar, Decl(NavigationView.js, 0, 6))
+
+import {layout} from '../../utils/theme'; // <- DO NOT DROP this import
+>layout : Symbol(layout, Decl(NavigationView.js, 1, 8))
+
+const x = <TabBar height={layout.footerHeight} />;
+>x : Symbol(x, Decl(NavigationView.js, 2, 5))
+>TabBar : Symbol(TabBar, Decl(NavigationView.js, 0, 6))
+>height : Symbol(layout)
+>layout : Symbol(layout, Decl(NavigationView.js, 1, 8))
+
diff --git a/tests/baselines/reference/reactImportDropped.types b/tests/baselines/reference/reactImportDropped.types
new file mode 100644
index 00000000000..36f1a6a4779
--- /dev/null
+++ b/tests/baselines/reference/reactImportDropped.types
@@ -0,0 +1,74 @@
+=== tests/cases/compiler/react.d.ts ===
+
+export = React;
+>React : typeof React
+
+export as namespace React;
+>React : typeof React
+
+declare namespace React {
+>React : typeof React
+
+    function createClass(spec: any): ClassicComponentClass;
+>createClass : (spec: any) => ClassicComponentClass
+>spec : any
+>ClassicComponentClass : ClassicComponentClass
+
+    interface ClassicComponentClass {
+>ClassicComponentClass : ClassicComponentClass
+
+        new (props?: any): ClassicComponentClass;
+>props : any
+>ClassicComponentClass : ClassicComponentClass
+    }
+}
+
+declare global {
+>global : any
+
+    namespace JSX {
+>JSX : any
+
+        interface ElementAttributesProperty { }
+>ElementAttributesProperty : ElementAttributesProperty
+    }
+}
+
+
+=== tests/cases/compiler/src/components/TabBar.js ===
+export default React.createClass({
+>React.createClass({  render() {    return (      null    );  }}) : React.ClassicComponentClass
+>React.createClass : (spec: any) => React.ClassicComponentClass
+>React : typeof React
+>createClass : (spec: any) => React.ClassicComponentClass
+>{  render() {    return (      null    );  }} : { render(): any; }
+
+  render() {
+>render : () => any
+
+    return (
+>(      null    ) : null
+
+      null
+>null : null
+
+    );
+  }
+});
+
+=== tests/cases/compiler/src/modules/navigation/NavigationView.js ===
+import TabBar from '../../components/TabBar';
+>TabBar : React.ClassicComponentClass
+
+import {layout} from '../../utils/theme'; // <- DO NOT DROP this import
+>layout : any
+
+const x = <TabBar height={layout.footerHeight} />;
+>x : any
+><TabBar height={layout.footerHeight} /> : any
+>TabBar : React.ClassicComponentClass
+>height : any
+>layout.footerHeight : any
+>layout : any
+>footerHeight : any
+
diff --git a/tests/cases/compiler/reactImportDropped.ts b/tests/cases/compiler/reactImportDropped.ts
new file mode 100644
index 00000000000..a345e7c74fd
--- /dev/null
+++ b/tests/cases/compiler/reactImportDropped.ts
@@ -0,0 +1,42 @@
+//@module: es6
+//@moduleResolution: node
+//@target: es6
+//@noImplicitAny: false
+//@allowSyntheticDefaultImports: true
+//@allowJs: true
+//@jsx: react
+//@outDir: "build"
+
+//@filename: react.d.ts
+export = React;
+export as namespace React;
+
+declare namespace React {
+
+    function createClass(spec: any): ClassicComponentClass;
+
+    interface ClassicComponentClass {
+        new (props?: any): ClassicComponentClass;
+    }
+}
+
+declare global {
+    namespace JSX {
+        interface ElementAttributesProperty { }
+    }
+}
+
+
+//@filename: src/components/TabBar.js
+export default React.createClass({
+  render() {
+    return (
+      null
+    );
+  }
+});
+
+//@filename: src/modules/navigation/NavigationView.js
+import TabBar from '../../components/TabBar';
+import {layout} from '../../utils/theme'; // <- DO NOT DROP this import
+const x = <TabBar height={layout.footerHeight} />;

From 16bdaaa0a6db70a3594d3e847545e6ce370ce620 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 25 Jan 2017 11:04:23 -0800
Subject: [PATCH 117/159] Fix positionToLineOffset conversion for
 getImplementation

---
 src/server/session.ts                         | 16 +++++++++-------
 .../goToImplementation_inDifferentFiles.ts    | 19 +++++++++++++++++++
 2 files changed, 28 insertions(+), 7 deletions(-)
 create mode 100644 tests/cases/fourslash/server/goToImplementation_inDifferentFiles.ts

diff --git a/src/server/session.ts b/src/server/session.ts
index 1fa3986f66f..825ad8506d7 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -484,18 +484,20 @@ namespace ts.server {
 
         private getImplementation(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.FileSpan[] | ImplementationLocation[] {
             const { file, project } = this.getFileAndProject(args);
-            const scriptInfo = project.getScriptInfoForNormalizedPath(file);
-            const position = this.getPosition(args, scriptInfo);
+            const position = this.getPosition(args, project.getScriptInfoForNormalizedPath(file));
             const implementations = project.getLanguageService().getImplementationAtPosition(file, position);
             if (!implementations) {
                 return [];
             }
             if (simplifiedResult) {
-                return implementations.map(impl => ({
-                    file: impl.fileName,
-                    start: scriptInfo.positionToLineOffset(impl.textSpan.start),
-                    end: scriptInfo.positionToLineOffset(ts.textSpanEnd(impl.textSpan))
-                }));
+                return implementations.map(({ fileName, textSpan }) => {
+                    const scriptInfo = project.getScriptInfo(fileName);
+                    return {
+                        file: fileName,
+                        start: scriptInfo.positionToLineOffset(textSpan.start),
+                        end: scriptInfo.positionToLineOffset(ts.textSpanEnd(textSpan))
+                    };
+                });
             }
             else {
                 return implementations;
diff --git a/tests/cases/fourslash/server/goToImplementation_inDifferentFiles.ts b/tests/cases/fourslash/server/goToImplementation_inDifferentFiles.ts
new file mode 100644
index 00000000000..e4289b83102
--- /dev/null
+++ b/tests/cases/fourslash/server/goToImplementation_inDifferentFiles.ts
@@ -0,0 +1,19 @@
+/// <reference path='../fourslash.ts'/>
+
+// @Filename: /bar.ts
+////import {Foo} from './foo'
+////
+////[|class A implements Foo {
+////    func() {}
+////}|]
+////
+////[|class B implements Foo {
+////    func() {}
+////}|]
+
+// @Filename: /foo.ts
+////export interface /**/Foo {
+////    func();
+////}
+
+verify.allRangesAppearInImplementationList("");

From 916e67a92c0c9d348ac74f8f3e78374d55964d78 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 25 Jan 2017 08:32:08 -0800
Subject: [PATCH 118/159] For goToDefinition, verify that
 tryGetSignatureDeclaration returns a signature declaration and not a
 FunctionType.

---
 src/services/goToDefinition.ts                  | 17 +++++++++++++++--
 .../fourslash/goToDefinitionFunctionType.ts     | 17 +++++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)
 create mode 100644 tests/cases/fourslash/goToDefinitionFunctionType.ts

diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts
index ab35a17fcef..73cf06d31ef 100644
--- a/src/services/goToDefinition.ts
+++ b/src/services/goToDefinition.ts
@@ -187,7 +187,15 @@ namespace ts.GoToDefinition {
     }
 
     function isSignatureDeclaration(node: Node): boolean {
-        return node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature
+        switch (node.kind) {
+            case ts.SyntaxKind.Constructor:
+            case ts.SyntaxKind.FunctionDeclaration:
+            case ts.SyntaxKind.MethodDeclaration:
+            case ts.SyntaxKind.MethodSignature:
+                return true;
+            default:
+                return false;
+        }
     }
 
     /** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */
@@ -254,6 +262,11 @@ namespace ts.GoToDefinition {
 
     function tryGetSignatureDeclaration(typeChecker: TypeChecker, node: Node): SignatureDeclaration | undefined {
         const callLike = getAncestorCallLikeExpression(node);
-        return callLike && typeChecker.getResolvedSignature(callLike).declaration;
+        const decl = callLike && typeChecker.getResolvedSignature(callLike).declaration;
+        if (decl && isSignatureDeclaration(decl)) {
+            return decl;
+        }
+        // Don't go to a function type, go to the value having that type.
+        return undefined;
     }
 }
diff --git a/tests/cases/fourslash/goToDefinitionFunctionType.ts b/tests/cases/fourslash/goToDefinitionFunctionType.ts
new file mode 100644
index 00000000000..1b50de3af6d
--- /dev/null
+++ b/tests/cases/fourslash/goToDefinitionFunctionType.ts
@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts'/>
+
+// Tests that goToDefinition does not go to a function type; it goes to the value.
+
+////const /*constDefinition*/c: () => void;
+/////*constReference*/c();
+////function test(/*cbDefinition*/cb: () => void) {
+////    /*cbReference*/cb();
+////}
+////class C {
+////    /*propDefinition*/prop: () => void;
+////    m() {
+////        this./*propReference*/prop();
+////    }
+////}
+
+verify.goToDefinitionForMarkers("const", "cb", "prop");

From 97e964a08f242eb806962d9d53e1d92f7d764fc8 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 25 Jan 2017 14:15:06 -0800
Subject: [PATCH 119/159] Fix typo

---
 tests/cases/fourslash/findAllRefsForMappedType.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/cases/fourslash/findAllRefsForMappedType.ts b/tests/cases/fourslash/findAllRefsForMappedType.ts
index 620eae0815c..38fb3a226c6 100644
--- a/tests/cases/fourslash/findAllRefsForMappedType.ts
+++ b/tests/cases/fourslash/findAllRefsForMappedType.ts
@@ -1,7 +1,7 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface T { [|a|]: number };
-////type U { [K in keyof T]: string };
+////type U = { [K in keyof T]: string };
 ////type V = { [K in keyof U]: boolean };
 ////const u: U = { [|a|]: "" }
 ////const v: V = { [|a|]: true }

From 5bf9b30c5d596037a10bdf78213b711fac20efbf Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 26 Jan 2017 09:50:38 -0800
Subject: [PATCH 120/159] Replace `isSearchedFor` with directly passing
 `searchSymbols`

---
 src/services/findAllReferences.ts | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index df568f6df3e..28474839cf3 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -41,9 +41,6 @@ namespace ts.FindAllReferences {
         if (shorthandModuleSymbol) {
             searchSymbols.push(shorthandModuleSymbol);
         }
-        function isSearchedFor(symbol: Symbol): boolean {
-            return contains(searchSymbols, symbol);
-        }
 
         // Compute the meaning from the location and the symbol it references
         const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
@@ -80,7 +77,7 @@ namespace ts.FindAllReferences {
 
         function getRefs(scope: ts.Node, searchName: string): void {
             getReferencesInNode(scope, symbol, searchName, node, searchMeaning, findInStrings, findInComments, result,
-                symbolToIndex, implementations, typeChecker, cancellationToken, isSearchedFor, inheritsFromCache);
+                symbolToIndex, implementations, typeChecker, cancellationToken, searchSymbols, inheritsFromCache);
         }
     }
 
@@ -456,7 +453,7 @@ namespace ts.FindAllReferences {
         implementations: boolean,
         typeChecker: TypeChecker,
         cancellationToken: CancellationToken,
-        isSearchedFor: (symbol: Symbol) => boolean,
+        searchSymbols: Symbol[],
         inheritsFromCache: Map<boolean>): void {
 
         const sourceFile = container.getSourceFile();
@@ -502,7 +499,7 @@ namespace ts.FindAllReferences {
             if (referenceSymbol) {
                 const referenceSymbolDeclaration = referenceSymbol.valueDeclaration;
                 const shorthandValueSymbol = typeChecker.getShorthandAssignmentValueSymbol(referenceSymbolDeclaration);
-                const relatedSymbol = getRelatedSymbol(isSearchedFor, referenceSymbol, referenceLocation,
+                const relatedSymbol = getRelatedSymbol(searchSymbols, referenceSymbol, referenceLocation,
                     /*searchLocationIsConstructor*/ searchLocation.kind === SyntaxKind.ConstructorKeyword, parents, inheritsFromCache, typeChecker);
 
                 if (relatedSymbol) {
@@ -514,7 +511,7 @@ namespace ts.FindAllReferences {
                  * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
                  * position of property accessing, the referenceEntry of such position will be handled in the first case.
                  */
-                else if (!(referenceSymbol.flags & SymbolFlags.Transient) && isSearchedFor(shorthandValueSymbol)) {
+                else if (!(referenceSymbol.flags & SymbolFlags.Transient) && contains(searchSymbols, shorthandValueSymbol)) {
                     addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
                 }
                 else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
@@ -1178,8 +1175,8 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function getRelatedSymbol(isSearchedFor: (symbol: Symbol) => boolean, referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>, typeChecker: TypeChecker): Symbol | undefined {
-        if (isSearchedFor(referenceSymbol)) {
+    function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node, searchLocationIsConstructor: boolean, parents: Symbol[] | undefined, cache: Map<boolean>, typeChecker: TypeChecker): Symbol | undefined {
+        if (contains(searchSymbols, referenceSymbol)) {
             // If we are searching for constructor uses, they must be 'new' expressions.
             return (!searchLocationIsConstructor || isNewExpressionTarget(referenceLocation)) ? referenceSymbol : undefined;
         }
@@ -1188,7 +1185,7 @@ namespace ts.FindAllReferences {
         // symbols but by looking up for related symbol of this alias so it can handle multiple level of indirectness.
         const aliasSymbol = getAliasSymbolForPropertyNameSymbol(referenceSymbol, referenceLocation, typeChecker);
         if (aliasSymbol) {
-            return getRelatedSymbol(isSearchedFor, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker);
+            return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation, searchLocationIsConstructor, parents, cache, typeChecker);
         }
 
         // If the reference location is in an object literal, try to get the contextual type for the
@@ -1197,7 +1194,7 @@ namespace ts.FindAllReferences {
         const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
         if (containingObjectLiteralElement) {
             const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol =>
-                find(typeChecker.getRootSymbols(contextualSymbol), isSearchedFor));
+                find(typeChecker.getRootSymbols(contextualSymbol), symbol => contains(searchSymbols, symbol)));
 
             if (contextualSymbol) {
                 return contextualSymbol;
@@ -1208,7 +1205,7 @@ namespace ts.FindAllReferences {
             // In below eg. get 'property' from type of elems iterating type
             //      for ( { property: p2 } of elems) { }
             const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, typeChecker);
-            if (propertySymbol && isSearchedFor(propertySymbol)) {
+            if (propertySymbol && contains(searchSymbols, propertySymbol)) {
                 return propertySymbol;
             }
         }
@@ -1217,7 +1214,7 @@ namespace ts.FindAllReferences {
         // then include the binding element in the related symbols
         //      let { a } : { a };
         const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, typeChecker);
-        if (bindingElementPropertySymbol && isSearchedFor(bindingElementPropertySymbol)) {
+        if (bindingElementPropertySymbol && contains(searchSymbols, bindingElementPropertySymbol)) {
             return bindingElementPropertySymbol;
         }
 
@@ -1225,7 +1222,7 @@ namespace ts.FindAllReferences {
         // Or a union property, use its underlying unioned symbols
         return forEach(typeChecker.getRootSymbols(referenceSymbol), rootSymbol => {
             // if it is in the list, then we are done
-            if (isSearchedFor(rootSymbol)) {
+            if (contains(searchSymbols, rootSymbol)) {
                 return rootSymbol;
             }
 
@@ -1242,7 +1239,7 @@ namespace ts.FindAllReferences {
 
                 const result: Symbol[] = [];
                 getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
-                return find(result, isSearchedFor);
+                return find(result, symbol => contains(searchSymbols, symbol));
             }
 
             return undefined;

From 71d1a3f051c0990c07a510dc811dfc4be4b3b6d7 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Thu, 26 Jan 2017 11:38:50 -0800
Subject: [PATCH 121/159] property handle misspelled namepath in @typedef tag
 (#13702)

---
 src/compiler/parser.ts                        |  9 ++++++--
 .../misspelledJsDocTypedefTags.symbols        |  8 +++++++
 .../misspelledJsDocTypedefTags.types          | 22 +++++++++++++++++++
 .../compiler/misspelledJsDocTypedefTags.ts    |  9 ++++++++
 4 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/misspelledJsDocTypedefTags.symbols
 create mode 100644 tests/baselines/reference/misspelledJsDocTypedefTags.types
 create mode 100644 tests/cases/compiler/misspelledJsDocTypedefTags.ts

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index c795cab14a3..c5439aa051b 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -6693,10 +6693,15 @@ namespace ts {
                     typedefTag.fullName = parseJSDocTypeNameWithNamespace(/*flags*/ 0);
                     if (typedefTag.fullName) {
                         let rightNode = typedefTag.fullName;
-                        while (rightNode.kind !== SyntaxKind.Identifier) {
+                        while (true) {
+                            if (rightNode.kind === SyntaxKind.Identifier || !rightNode.body) {
+                                // if node is identifier - use it as name
+                                // otherwise use name of the rightmost part that we were able to parse
+                                typedefTag.name = rightNode.kind === SyntaxKind.Identifier ? rightNode : rightNode.name;
+                                break;
+                            }
                             rightNode = rightNode.body;
                         }
-                        typedefTag.name = rightNode;
                     }
                     typedefTag.typeExpression = typeExpression;
                     skipWhitespace();
diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.symbols b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols
new file mode 100644
index 00000000000..bf3f6e7fab0
--- /dev/null
+++ b/tests/baselines/reference/misspelledJsDocTypedefTags.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/a.js ===
+
+No type information for this code./** @typedef {{ endTime: number, screenshots: number}} A.<b>*/
+No type information for this code.Animation.AnimationModel.ScreenshotCapture.Request;
+No type information for this code.
+No type information for this code./** @typedef {{ endTime: number, screenshots: !B.<string>}} */
+No type information for this code.Animation.AnimationModel.ScreenshotCapture.Request;
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/misspelledJsDocTypedefTags.types b/tests/baselines/reference/misspelledJsDocTypedefTags.types
new file mode 100644
index 00000000000..70cc011ea69
--- /dev/null
+++ b/tests/baselines/reference/misspelledJsDocTypedefTags.types
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/a.js ===
+
+/** @typedef {{ endTime: number, screenshots: number}} A.<b>*/
+Animation.AnimationModel.ScreenshotCapture.Request;
+>Animation.AnimationModel.ScreenshotCapture.Request : any
+>Animation.AnimationModel.ScreenshotCapture : any
+>Animation.AnimationModel : any
+>Animation : any
+>AnimationModel : any
+>ScreenshotCapture : any
+>Request : any
+
+/** @typedef {{ endTime: number, screenshots: !B.<string>}} */
+Animation.AnimationModel.ScreenshotCapture.Request;
+>Animation.AnimationModel.ScreenshotCapture.Request : any
+>Animation.AnimationModel.ScreenshotCapture : any
+>Animation.AnimationModel : any
+>Animation : any
+>AnimationModel : any
+>ScreenshotCapture : any
+>Request : any
+
diff --git a/tests/cases/compiler/misspelledJsDocTypedefTags.ts b/tests/cases/compiler/misspelledJsDocTypedefTags.ts
new file mode 100644
index 00000000000..3f3221020bd
--- /dev/null
+++ b/tests/cases/compiler/misspelledJsDocTypedefTags.ts
@@ -0,0 +1,9 @@
+// @allowJs: true
+// @noEmit: true
+
+// @filename: a.js
+/** @typedef {{ endTime: number, screenshots: number}} A.<b>*/
+Animation.AnimationModel.ScreenshotCapture.Request;
+
+/** @typedef {{ endTime: number, screenshots: !B.<string>}} */
+Animation.AnimationModel.ScreenshotCapture.Request;
\ No newline at end of file

From cabcaaadcbd505f264dc396aad97cee427459171 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Thu, 26 Jan 2017 16:04:58 -0800
Subject: [PATCH 122/159] Property assignment is not an assignment target

In a destructuring assignment, a property assignment is not an
assignment target. Its initialiser is. For example:

```ts
({ source: target} = o);
```

Here, `target` is the assignment target. `source` is not. Previously,
both were assignment targets.
---
 src/compiler/utilities.ts                     | 11 +++++---
 ...ertyAssignmentNameIsNotAssignmentTarget.js | 17 +++++++++++++
 ...ssignmentNameIsNotAssignmentTarget.symbols | 21 ++++++++++++++++
 ...yAssignmentNameIsNotAssignmentTarget.types | 25 +++++++++++++++++++
 ...ertyAssignmentNameIsNotAssignmentTarget.ts |  7 ++++++
 5 files changed, 78 insertions(+), 3 deletions(-)
 create mode 100644 tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.js
 create mode 100644 tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.symbols
 create mode 100644 tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.types
 create mode 100644 tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5c63d8bb60c..17e9fe8e1d7 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1662,11 +1662,15 @@ namespace ts {
                     node = parent;
                     break;
                 case SyntaxKind.ShorthandPropertyAssignment:
-                    if ((<ShorthandPropertyAssignment>parent).name !== node) {
+                    if ((parent as ShorthandPropertyAssignment).name !== node) {
                         return AssignmentKind.None;
                     }
-                // Fall through
+                    node = parent.parent;
+                    break;
                 case SyntaxKind.PropertyAssignment:
+                    if ((parent as ShorthandPropertyAssignment).name === node) {
+                        return AssignmentKind.None;
+                    }
                     node = parent.parent;
                     break;
                 default:
@@ -1678,7 +1682,8 @@ namespace ts {
 
     // A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property
     // assignment in an object literal that is an assignment target, or if it is parented by an array literal that is
-    // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'.
+    // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ a }] = xxx'.
+    // (Note that `p` is not a target in the above examples, only `a`.)
     export function isAssignmentTarget(node: Node): boolean {
         return getAssignmentTargetKind(node) !== AssignmentKind.None;
     }
diff --git a/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.js b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.js
new file mode 100644
index 00000000000..b2ba970ef51
--- /dev/null
+++ b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.js
@@ -0,0 +1,17 @@
+//// [destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts]
+// test for #10668
+function qux(bar: { value: number }) {
+    let foo: number;
+    ({ value: foo } = bar);
+    let x = () => bar;
+}
+
+
+
+//// [destructuringPropertyAssignmentNameIsNotAssignmentTarget.js]
+// test for #10668
+function qux(bar) {
+    var foo;
+    (foo = bar.value);
+    var x = function () { return bar; };
+}
diff --git a/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.symbols b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.symbols
new file mode 100644
index 00000000000..b9ebe219f65
--- /dev/null
+++ b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.symbols
@@ -0,0 +1,21 @@
+=== tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts ===
+// test for #10668
+function qux(bar: { value: number }) {
+>qux : Symbol(qux, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 0, 0))
+>bar : Symbol(bar, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 1, 13))
+>value : Symbol(value, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 1, 19))
+
+    let foo: number;
+>foo : Symbol(foo, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 2, 7))
+
+    ({ value: foo } = bar);
+>value : Symbol(value, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 3, 6))
+>foo : Symbol(foo, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 2, 7))
+>bar : Symbol(bar, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 1, 13))
+
+    let x = () => bar;
+>x : Symbol(x, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 4, 7))
+>bar : Symbol(bar, Decl(destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts, 1, 13))
+}
+
+
diff --git a/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.types b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.types
new file mode 100644
index 00000000000..e0428fc959f
--- /dev/null
+++ b/tests/baselines/reference/destructuringPropertyAssignmentNameIsNotAssignmentTarget.types
@@ -0,0 +1,25 @@
+=== tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts ===
+// test for #10668
+function qux(bar: { value: number }) {
+>qux : (bar: { value: number; }) => void
+>bar : { value: number; }
+>value : number
+
+    let foo: number;
+>foo : number
+
+    ({ value: foo } = bar);
+>({ value: foo } = bar) : { value: number; }
+>{ value: foo } = bar : { value: number; }
+>{ value: foo } : { value: number; }
+>value : number
+>foo : number
+>bar : { value: number; }
+
+    let x = () => bar;
+>x : () => { value: number; }
+>() => bar : () => { value: number; }
+>bar : { value: number; }
+}
+
+
diff --git a/tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts b/tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts
new file mode 100644
index 00000000000..c0002f3e80a
--- /dev/null
+++ b/tests/cases/compiler/destructuringPropertyAssignmentNameIsNotAssignmentTarget.ts
@@ -0,0 +1,7 @@
+// test for #10668
+function qux(bar: { value: number }) {
+    let foo: number;
+    ({ value: foo } = bar);
+    let x = () => bar;
+}
+

From 4d67b0c2b6f4cb99b74db702eda6eb62c1cda7f4 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Fri, 27 Jan 2017 09:53:57 -0800
Subject: [PATCH 123/159] Allow super to access method signatures

Previously, super was only allowed to access method *declarations*. But
method signatures can come from interfaces that merge with classes, and
should also be accessible as methods on super.
---
 src/compiler/checker.ts                       | 13 ++++---
 .../superHasMethodsFromMergedInterface.js     | 37 +++++++++++++++++++
 ...superHasMethodsFromMergedInterface.symbols | 23 ++++++++++++
 .../superHasMethodsFromMergedInterface.types  | 24 ++++++++++++
 .../superHasMethodsFromMergedInterface.ts     |  7 ++++
 5 files changed, 99 insertions(+), 5 deletions(-)
 create mode 100644 tests/baselines/reference/superHasMethodsFromMergedInterface.js
 create mode 100644 tests/baselines/reference/superHasMethodsFromMergedInterface.symbols
 create mode 100644 tests/baselines/reference/superHasMethodsFromMergedInterface.types
 create mode 100644 tests/cases/compiler/superHasMethodsFromMergedInterface.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 7c8a0b7337f..7d0f2cb0bbb 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -12337,12 +12337,15 @@ namespace ts {
                 // - In a static member function or static member accessor
                 //   where this references the constructor function object of a derived class,
                 //   a super property access is permitted and must specify a public static member function of the base class.
-                if (languageVersion < ScriptTarget.ES2015 && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) {
-                    // `prop` refers to a *property* declared in the super class
-                    // rather than a *method*, so it does not satisfy the above criteria.
+                if (languageVersion < ScriptTarget.ES2015) {
+                    const propKind = getDeclarationKindFromSymbol(prop);
+                    if (propKind !== SyntaxKind.MethodDeclaration && propKind !== SyntaxKind.MethodSignature) {
+                        // `prop` refers to a *property* declared in the super class
+                        // rather than a *method*, so it does not satisfy the above criteria.
 
-                    error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
-                    return false;
+                        error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
+                        return false;
+                    }
                 }
 
                 if (flags & ModifierFlags.Abstract) {
diff --git a/tests/baselines/reference/superHasMethodsFromMergedInterface.js b/tests/baselines/reference/superHasMethodsFromMergedInterface.js
new file mode 100644
index 00000000000..e7086106210
--- /dev/null
+++ b/tests/baselines/reference/superHasMethodsFromMergedInterface.js
@@ -0,0 +1,37 @@
+//// [superHasMethodsFromMergedInterface.ts]
+class C { m1() { } }
+interface C { m2(): void }
+class Sub extends C {
+    m3() {
+        super.m2();
+    }
+}
+
+
+//// [superHasMethodsFromMergedInterface.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var C = (function () {
+    function C() {
+    }
+    C.prototype.m1 = function () { };
+    return C;
+}());
+var Sub = (function (_super) {
+    __extends(Sub, _super);
+    function Sub() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Sub.prototype.m3 = function () {
+        _super.prototype.m2.call(this);
+    };
+    return Sub;
+}(C));
diff --git a/tests/baselines/reference/superHasMethodsFromMergedInterface.symbols b/tests/baselines/reference/superHasMethodsFromMergedInterface.symbols
new file mode 100644
index 00000000000..ec0af8064ed
--- /dev/null
+++ b/tests/baselines/reference/superHasMethodsFromMergedInterface.symbols
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/superHasMethodsFromMergedInterface.ts ===
+class C { m1() { } }
+>C : Symbol(C, Decl(superHasMethodsFromMergedInterface.ts, 0, 0), Decl(superHasMethodsFromMergedInterface.ts, 0, 20))
+>m1 : Symbol(C.m1, Decl(superHasMethodsFromMergedInterface.ts, 0, 9))
+
+interface C { m2(): void }
+>C : Symbol(C, Decl(superHasMethodsFromMergedInterface.ts, 0, 0), Decl(superHasMethodsFromMergedInterface.ts, 0, 20))
+>m2 : Symbol(C.m2, Decl(superHasMethodsFromMergedInterface.ts, 1, 13))
+
+class Sub extends C {
+>Sub : Symbol(Sub, Decl(superHasMethodsFromMergedInterface.ts, 1, 26))
+>C : Symbol(C, Decl(superHasMethodsFromMergedInterface.ts, 0, 0), Decl(superHasMethodsFromMergedInterface.ts, 0, 20))
+
+    m3() {
+>m3 : Symbol(Sub.m3, Decl(superHasMethodsFromMergedInterface.ts, 2, 21))
+
+        super.m2();
+>super.m2 : Symbol(C.m2, Decl(superHasMethodsFromMergedInterface.ts, 1, 13))
+>super : Symbol(C, Decl(superHasMethodsFromMergedInterface.ts, 0, 0), Decl(superHasMethodsFromMergedInterface.ts, 0, 20))
+>m2 : Symbol(C.m2, Decl(superHasMethodsFromMergedInterface.ts, 1, 13))
+    }
+}
+
diff --git a/tests/baselines/reference/superHasMethodsFromMergedInterface.types b/tests/baselines/reference/superHasMethodsFromMergedInterface.types
new file mode 100644
index 00000000000..7f314d90bed
--- /dev/null
+++ b/tests/baselines/reference/superHasMethodsFromMergedInterface.types
@@ -0,0 +1,24 @@
+=== tests/cases/compiler/superHasMethodsFromMergedInterface.ts ===
+class C { m1() { } }
+>C : C
+>m1 : () => void
+
+interface C { m2(): void }
+>C : C
+>m2 : () => void
+
+class Sub extends C {
+>Sub : Sub
+>C : C
+
+    m3() {
+>m3 : () => void
+
+        super.m2();
+>super.m2() : void
+>super.m2 : () => void
+>super : C
+>m2 : () => void
+    }
+}
+
diff --git a/tests/cases/compiler/superHasMethodsFromMergedInterface.ts b/tests/cases/compiler/superHasMethodsFromMergedInterface.ts
new file mode 100644
index 00000000000..cdca6ae65bf
--- /dev/null
+++ b/tests/cases/compiler/superHasMethodsFromMergedInterface.ts
@@ -0,0 +1,7 @@
+class C { m1() { } }
+interface C { m2(): void }
+class Sub extends C {
+    m3() {
+        super.m2();
+    }
+}

From 89b72ac9cec52d3a663f17daaabebc219c207644 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sat, 28 Jan 2017 14:46:29 -0800
Subject: [PATCH 124/159] Support mixin classes

---
 src/compiler/checker.ts              | 86 +++++++++++++++++++++++-----
 src/compiler/diagnosticMessages.json |  4 ++
 2 files changed, 76 insertions(+), 14 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 7c8a0b7337f..6e0f0d6509a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2465,7 +2465,8 @@ namespace ts {
                     const symbol = type.symbol;
                     if (symbol) {
                         // Always use 'typeof T' for type of class, enum, and module objects
-                        if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
+                        if (symbol.flags & SymbolFlags.Class && !getBaseTypeVariableOfClass(symbol) ||
+                            symbol.flags & (SymbolFlags.Enum | SymbolFlags.ValueModule)) {
                             writeTypeOfSymbol(type, flags);
                         }
                         else if (shouldWriteTypeOfFunctionSymbol()) {
@@ -3639,6 +3640,11 @@ namespace ts {
             return links.type;
         }
 
+        function getBaseTypeVariableOfClass(symbol: Symbol) {
+            const baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
+            return baseConstructorType.flags & TypeFlags.TypeVariable ? baseConstructorType : undefined;
+        }
+
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
             if (!links.type) {
@@ -3647,8 +3653,13 @@ namespace ts {
                 }
                 else {
                     const type = createObjectType(ObjectFlags.Anonymous, symbol);
-                    links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ?
-                        includeFalsyTypes(type, TypeFlags.Undefined) : type;
+                    if (symbol.flags & SymbolFlags.Class) {
+                        const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
+                        links.type = baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
+                    }
+                    else {
+                        links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ? includeFalsyTypes(type, TypeFlags.Undefined) : type;
+                    }
                 }
             }
             return links.type;
@@ -3812,8 +3823,26 @@ namespace ts {
             return concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
         }
 
+        // A type is a mixin constructor if it has a single construct signature taking no type parameters and a single
+        // rest parameter of type any[].
+        function isMixinConstructorType(type: Type) {
+            const signatures = getSignaturesOfType(type, SignatureKind.Construct);
+            if (signatures.length === 1) {
+                const s = signatures[0];
+                return !s.typeParameters && s.parameters.length === 1 && s.hasRestParameter && getTypeOfParameter(s.parameters[0]) === anyArrayType;
+            }
+            return false;
+        }
+
         function isConstructorType(type: Type): boolean {
-            return isValidBaseType(type) && getSignaturesOfType(type, SignatureKind.Construct).length > 0;
+            if (isValidBaseType(type) && getSignaturesOfType(type, SignatureKind.Construct).length > 0) {
+                return true;
+            }
+            if (type.flags & TypeFlags.TypeVariable) {
+                const constraint = getBaseConstraintOfType(<TypeVariable>type);
+                return isValidBaseType(constraint) && isMixinConstructorType(constraint);
+            }
+            return false;
         }
 
         function getBaseTypeNodeOfClass(type: InterfaceType): ExpressionWithTypeArguments {
@@ -3892,7 +3921,7 @@ namespace ts {
 
         function resolveBaseTypesOfClass(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
-            const baseConstructorType = <ObjectType>getBaseConstructorTypeOfClass(type);
+            const baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type));
             if (!(baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection))) {
                 return;
             }
@@ -4547,11 +4576,32 @@ namespace ts {
             // intersection type use getPropertiesOfType (only the language service uses this).
             let callSignatures: Signature[] = emptyArray;
             let constructSignatures: Signature[] = emptyArray;
-            let stringIndexInfo: IndexInfo = undefined;
-            let numberIndexInfo: IndexInfo = undefined;
-            for (const t of type.types) {
+            let stringIndexInfo: IndexInfo;
+            let numberIndexInfo: IndexInfo;
+            let mixinTypes: Type[];
+            const count = type.types.length;
+            for (let i = 0; i < count; i++) {
+                const t = type.types[i];
+                // When a type T is preceded by a mixin constructor type, the return type of each construct signature
+                // in T is intersected with the return type of the mixin constructor, and the mixin construct signature
+                // is removed. For example, the intersection '{ new(...args: any[]) => A } & { new(s: string) => B }'
+                // has a single construct signature 'new(s: string) => A & B'.
+                let signatures = getSignaturesOfType(t, SignatureKind.Construct);
+                if (i < count - 1 && isMixinConstructorType(t)) {
+                    (mixinTypes || (mixinTypes = [])).push(getReturnTypeOfSignature(signatures[0]));
+                }
+                else {
+                    if (mixinTypes) {
+                        signatures = map(signatures, s => {
+                            const clone = cloneSignature(s);
+                            clone.resolvedReturnType = getIntersectionType([...mixinTypes, getReturnTypeOfSignature(s)]);
+                            return clone;
+                        });
+                        mixinTypes = undefined;
+                    }
+                    constructSignatures = concatenate(constructSignatures, signatures);
+                }
                 callSignatures = concatenate(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
-                constructSignatures = concatenate(constructSignatures, getSignaturesOfType(t, SignatureKind.Construct));
                 stringIndexInfo = intersectIndexInfos(stringIndexInfo, getIndexInfoOfType(t, IndexKind.String));
                 numberIndexInfo = intersectIndexInfos(numberIndexInfo, getIndexInfoOfType(t, IndexKind.Number));
             }
@@ -4593,7 +4643,7 @@ namespace ts {
                         constructSignatures = getDefaultConstructSignatures(classType);
                     }
                     const baseConstructorType = getBaseConstructorTypeOfClass(classType);
-                    if (baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection)) {
+                    if (baseConstructorType.flags & (TypeFlags.Object | TypeFlags.Intersection | TypeFlags.TypeVariable)) {
                         members = createSymbolTable(getNamedMembers(members));
                         addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
                     }
@@ -4890,6 +4940,7 @@ namespace ts {
 
         function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: string): Symbol {
             const types = containingType.types;
+            const excludeModifiers = containingType.flags & TypeFlags.Union ? ModifierFlags.Private | ModifierFlags.Protected : 0;
             let props: Symbol[];
             // Flags we want to propagate to the result if they exist in all source symbols
             let commonFlags = (containingType.flags & TypeFlags.Intersection) ? SymbolFlags.Optional : SymbolFlags.None;
@@ -4899,7 +4950,7 @@ namespace ts {
                 const type = getApparentType(current);
                 if (type !== unknownType) {
                     const prop = getPropertyOfType(type, name);
-                    if (prop && !(getDeclarationModifierFlagsFromSymbol(prop) & (ModifierFlags.Private | ModifierFlags.Protected))) {
+                    if (prop && !(getDeclarationModifierFlagsFromSymbol(prop) & excludeModifiers)) {
                         commonFlags &= prop.flags;
                         if (!props) {
                             props = [prop];
@@ -6965,9 +7016,12 @@ namespace ts {
                     result.properties = resolved.properties;
                     result.callSignatures = emptyArray;
                     result.constructSignatures = emptyArray;
-                    type = result;
+                    return result;
                 }
             }
+            else if (type.flags & TypeFlags.Intersection) {
+                return getIntersectionType(map((<IntersectionType>type).types, getTypeWithoutSignatures));
+            }
             return type;
         }
 
@@ -18387,7 +18441,8 @@ namespace ts {
                 const baseTypes = getBaseTypes(type);
                 if (baseTypes.length && produceDiagnostics) {
                     const baseType = baseTypes[0];
-                    const staticBaseType = getBaseConstructorTypeOfClass(type);
+                    const baseConstructorType = getBaseConstructorTypeOfClass(type);
+                    const staticBaseType = getApparentType(baseConstructorType);
                     checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
                     checkSourceElement(baseTypeNode.expression);
                     if (baseTypeNode.typeArguments) {
@@ -18401,6 +18456,9 @@ namespace ts {
                     checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1);
                     checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node,
                         Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                    if (baseConstructorType.flags & TypeFlags.TypeVariable && !isMixinConstructorType(staticType)) {
+                        error(node.name || node, Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
+                    }
 
                     if (baseType.symbol && baseType.symbol.valueDeclaration &&
                         !isInAmbientContext(baseType.symbol.valueDeclaration) &&
@@ -18410,7 +18468,7 @@ namespace ts {
                         }
                     }
 
-                    if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) {
+                    if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class) && !(baseConstructorType.flags & TypeFlags.TypeVariable)) {
                         // When the static base type is a "class-like" constructor function (but not actually a class), we verify
                         // that all instantiated base constructor signatures return the same type. We can simply compare the type
                         // references (as opposed to checking the structure of the types) because elsewhere we have already checked
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 43a9cce4de6..3fa399d3d38 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1783,6 +1783,10 @@
         "category": "Error",
         "code": 2544
     },
+    "A mixin class must have a constructor with a single rest parameter of type 'any[]'.": {
+        "category": "Error",
+        "code": 2545
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600

From 763df852c610d9bc1e098fb7529474e7a7e52f92 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 29 Jan 2017 08:14:28 -0800
Subject: [PATCH 125/159] Revise intersection construct signature mixin
 algorithm

---
 src/compiler/checker.ts | 40 +++++++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6e0f0d6509a..dff8953e913 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4571,6 +4571,19 @@ namespace ts {
                 getUnionType([info1.type, info2.type]), info1.isReadonly || info2.isReadonly);
         }
 
+        function includeMixinType(type: Type, types: Type[], index: number): Type {
+            const mixedTypes: Type[] = [];
+            for (let i = 0; i < types.length; i++) {
+                if (i === index) {
+                    mixedTypes.push(type);
+                }
+                else if (isMixinConstructorType(types[i])) {
+                    mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], SignatureKind.Construct)[0]));
+                }
+            }
+            return getIntersectionType(mixedTypes);
+        }
+
         function resolveIntersectionTypeMembers(type: IntersectionType) {
             // The members and properties collections are empty for intersection types. To get all properties of an
             // intersection type use getPropertiesOfType (only the language service uses this).
@@ -4578,26 +4591,23 @@ namespace ts {
             let constructSignatures: Signature[] = emptyArray;
             let stringIndexInfo: IndexInfo;
             let numberIndexInfo: IndexInfo;
-            let mixinTypes: Type[];
-            const count = type.types.length;
-            for (let i = 0; i < count; i++) {
+            const types = type.types;
+            const mixinCount = countWhere(types, isMixinConstructorType);
+            for (let i = 0; i < types.length; i++) {
                 const t = type.types[i];
-                // When a type T is preceded by a mixin constructor type, the return type of each construct signature
-                // in T is intersected with the return type of the mixin constructor, and the mixin construct signature
-                // is removed. For example, the intersection '{ new(...args: any[]) => A } & { new(s: string) => B }'
-                // has a single construct signature 'new(s: string) => A & B'.
-                let signatures = getSignaturesOfType(t, SignatureKind.Construct);
-                if (i < count - 1 && isMixinConstructorType(t)) {
-                    (mixinTypes || (mixinTypes = [])).push(getReturnTypeOfSignature(signatures[0]));
-                }
-                else {
-                    if (mixinTypes) {
+                // When an intersection type contains mixin constructor types, the construct signatures from
+                // those types are discarded and their return types are mixed into the return types of all
+                // other construct signatures in the intersection type. For example, the intersection type
+                // '{ new(...args: any[]) => A } & { new(s: string) => B }' has a single construct signature
+                // 'new(s: string) => A & B'.
+                if (mixinCount === 0 || mixinCount === types.length && i === 0 || !isMixinConstructorType(t)) {
+                    let signatures = getSignaturesOfType(t, SignatureKind.Construct);
+                    if (signatures.length && mixinCount > 0) {
                         signatures = map(signatures, s => {
                             const clone = cloneSignature(s);
-                            clone.resolvedReturnType = getIntersectionType([...mixinTypes, getReturnTypeOfSignature(s)]);
+                            clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, i);
                             return clone;
                         });
-                        mixinTypes = undefined;
                     }
                     constructSignatures = concatenate(constructSignatures, signatures);
                 }

From 028e4e2b13b4a65d5418865cc22d3b37c935c955 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Thu, 26 Jan 2017 15:46:26 -0800
Subject: [PATCH 126/159] Extract printer from emitter for reusability.

---
 Jakefile.js                                |    2 +
 src/compiler/comments.ts                   |   20 +-
 src/compiler/declarationEmitter.ts         |   16 +-
 src/compiler/emitter.ts                    | 2781 +-------------------
 src/compiler/factory.ts                    |   13 +
 src/compiler/printer.ts                    | 2659 +++++++++++++++++++
 src/compiler/sourcemap.ts                  |   28 +-
 src/compiler/transformer.ts                |   30 +-
 src/compiler/transformers/es2015.ts        |   16 +-
 src/compiler/transformers/es2017.ts        |   16 +-
 src/compiler/transformers/es5.ts           |   18 +-
 src/compiler/transformers/generators.ts    |    6 +-
 src/compiler/transformers/module/es2015.ts |   16 +-
 src/compiler/transformers/module/module.ts |   16 +-
 src/compiler/transformers/module/system.ts |   18 +-
 src/compiler/transformers/ts.ts            |   14 +-
 src/compiler/tsconfig.json                 |    1 +
 src/compiler/types.ts                      |   75 +-
 src/compiler/utilities.ts                  |   42 +-
 src/harness/tsconfig.json                  |    1 +
 src/services/tsconfig.json                 |    1 +
 21 files changed, 2939 insertions(+), 2850 deletions(-)
 create mode 100644 src/compiler/printer.ts

diff --git a/Jakefile.js b/Jakefile.js
index 3ee8476c842..a23b9cbe03c 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -84,6 +84,7 @@ var compilerSources = [
     "sourcemap.ts",
     "comments.ts",
     "declarationEmitter.ts",
+    "printer.ts",
     "emitter.ts",
     "program.ts",
     "commandLineParser.ts",
@@ -121,6 +122,7 @@ var servicesSources = [
     "sourcemap.ts",
     "comments.ts",
     "declarationEmitter.ts",
+    "printer.ts",
     "emitter.ts",
     "program.ts",
     "commandLineParser.ts",
diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts
index bd9190dbec7..3106d3ccfec 100644
--- a/src/compiler/comments.ts
+++ b/src/compiler/comments.ts
@@ -5,17 +5,13 @@ namespace ts {
     export interface CommentWriter {
         reset(): void;
         setSourceFile(sourceFile: SourceFile): void;
-        emitNodeWithComments(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+        emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
         emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void): void;
         emitTrailingCommentsOfPosition(pos: number): void;
     }
 
-    export function createCommentWriter(host: EmitHost, writer: EmitTextWriter, sourceMap: SourceMapWriter): CommentWriter {
-        const compilerOptions = host.getCompilerOptions();
+    export function createCommentWriter(writer: EmitTextWriter, compilerOptions: CompilerOptions, newLine: string, emitPos: (pos: number) => void): CommentWriter {
         const extendedDiagnostics = compilerOptions.extendedDiagnostics;
-        const newLine = host.getNewLine();
-        const { emitPos } = sourceMap;
-
         let containerPos = -1;
         let containerEnd = -1;
         let declarationListContainerEnd = -1;
@@ -34,9 +30,9 @@ namespace ts {
             emitTrailingCommentsOfPosition,
         };
 
-        function emitNodeWithComments(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             if (disabled) {
-                emitCallback(emitContext, node);
+                emitCallback(hint, node);
                 return;
             }
 
@@ -47,11 +43,11 @@ namespace ts {
                     // Both pos and end are synthesized, so just emit the node without comments.
                     if (emitFlags & EmitFlags.NoNestedComments) {
                         disabled = true;
-                        emitCallback(emitContext, node);
+                        emitCallback(hint, node);
                         disabled = false;
                     }
                     else {
-                        emitCallback(emitContext, node);
+                        emitCallback(hint, node);
                     }
                 }
                 else {
@@ -94,11 +90,11 @@ namespace ts {
 
                     if (emitFlags & EmitFlags.NoNestedComments) {
                         disabled = true;
-                        emitCallback(emitContext, node);
+                        emitCallback(hint, node);
                         disabled = false;
                     }
                     else {
-                        emitCallback(emitContext, node);
+                        emitCallback(hint, node);
                     }
 
                     if (extendedDiagnostics) {
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 46df4fed689..4b878adaff5 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -35,13 +35,15 @@ namespace ts {
         forEachEmittedFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
         return declarationDiagnostics.getDiagnostics(targetSourceFile ? targetSourceFile.fileName : undefined);
 
-        function getDeclarationDiagnosticsFromFile({ declarationFilePath }: EmitFileNames, sources: SourceFile[], isBundledEmit: boolean) {
-            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sources, isBundledEmit, /*emitOnlyDtsFiles*/ false);
+        function getDeclarationDiagnosticsFromFile({ declarationFilePath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
+            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sourceFileOrBundle, /*emitOnlyDtsFiles*/ false);
         }
     }
 
     function emitDeclarations(host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, declarationFilePath: string,
-        sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean): DeclarationEmit {
+        sourceFileOrBundle: SourceFile | Bundle, emitOnlyDtsFiles: boolean): DeclarationEmit {
+        const sourceFiles = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle.sourceFiles : [sourceFileOrBundle];
+        const isBundledEmit = sourceFileOrBundle.kind === SyntaxKind.Bundle;
         const newLine = host.getNewLine();
         const compilerOptions = host.getCompilerOptions();
 
@@ -1803,8 +1805,9 @@ namespace ts {
             }
             return addedBundledEmitReference;
 
-            function getDeclFileName(emitFileNames: EmitFileNames, _sourceFiles: SourceFile[], isBundledEmit: boolean) {
+            function getDeclFileName(emitFileNames: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
                 // Dont add reference path to this file if it is a bundled emit and caller asked not emit bundled file path
+                const isBundledEmit = sourceFileOrBundle.kind === SyntaxKind.Bundle;
                 if (isBundledEmit && !addBundledFileReference) {
                     return;
                 }
@@ -1817,10 +1820,11 @@ namespace ts {
     }
 
     /* @internal */
-    export function writeDeclarationFile(declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, emitOnlyDtsFiles: boolean) {
-        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit, emitOnlyDtsFiles);
+    export function writeDeclarationFile(declarationFilePath: string, sourceFileOrBundle: SourceFile | Bundle, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, emitOnlyDtsFiles: boolean) {
+        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFileOrBundle, emitOnlyDtsFiles);
         const emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath) || host.getCompilerOptions().noEmit;
         if (!emitSkipped) {
+            const sourceFiles = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle.sourceFiles : [sourceFileOrBundle];
             const declarationOutput = emitDeclarationResult.referencesOutput
                 + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
             writeFile(host, emitterDiagnostics, declarationFilePath, declarationOutput, host.getCompilerOptions().emitBOM, sourceFiles);
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 27285a4c2dc..dd823cf7994 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1,61 +1,28 @@
-/// <reference path="checker.ts"/>
+/// <reference path="checker.ts" />
 /// <reference path="transformer.ts" />
-/// <reference path="declarationEmitter.ts"/>
-/// <reference path="sourcemap.ts"/>
+/// <reference path="declarationEmitter.ts" />
+/// <reference path="sourcemap.ts" />
 /// <reference path="comments.ts" />
+/// <reference path="printer.ts" />
 
 /* @internal */
 namespace ts {
-    // Flags enum to track count of temp variables and a few dedicated names
-    const enum TempFlags {
-        Auto      = 0x00000000,  // No preferred name
-        CountMask = 0x0FFFFFFF,  // Temp variable counter
-        _i        = 0x10000000,  // Use/preference flag for '_i'
-    }
-
     const id = (s: SourceFile) => s;
     const nullTransformers: Transformer[] = [_ => id];
 
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
     export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean): EmitResult {
-        const delimiters = createDelimiterMap();
-        const brackets = createBracketsMap();
         const compilerOptions = host.getCompilerOptions();
-        const languageVersion = getEmitScriptTarget(compilerOptions);
-        const moduleKind = getEmitModuleKind(compilerOptions);
         const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
         const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
         const newLine = host.getNewLine();
         const transformers: Transformer[] = emitOnlyDtsFiles ? nullTransformers : getTransformers(compilerOptions);
         const writer = createTextWriter(newLine);
-        const {
-            write,
-            writeLine,
-            increaseIndent,
-            decreaseIndent
-        } = writer;
-
         const sourceMap = createSourceMapWriter(host, writer);
-        const {
-            emitNodeWithSourceMap,
-            emitTokenWithSourceMap
-        } = sourceMap;
+        const comments = createCommentWriter(writer, compilerOptions, newLine, sourceMap.emitPos);
 
-        const comments = createCommentWriter(host, writer, sourceMap);
-        const {
-            emitNodeWithComments,
-            emitBodyWithDetachedComments,
-            emitTrailingCommentsOfPosition
-        } = comments;
-
-        let nodeIdToGeneratedName: string[];
-        let autoGeneratedIdToGeneratedName: string[];
-        let generatedNameSet: Map<string>;
-        let tempFlags: TempFlags;
         let currentSourceFile: SourceFile;
-        let currentText: string;
-        let currentFileIdentifiers: Map<string>;
         let bundledHelpers: Map<boolean>;
         let isOwnFileEmit: boolean;
         let emitSkipped = false;
@@ -63,17 +30,34 @@ namespace ts {
         const sourceFiles = getSourceFilesToEmit(host, targetSourceFile);
 
         // Transform the source files
-        performance.mark("beforeTransform");
-        const {
-            transformed,
-            emitNodeWithSubstitution,
-            emitNodeWithNotification
-        } = transformFiles(resolver, host, sourceFiles, transformers);
-        performance.measure("transformTime", "beforeTransform");
+        const transform = transformFiles(resolver, host, sourceFiles, transformers);
+
+        // Create a printer to print the nodes
+        const printer = createPrinter(writer, compilerOptions, {
+            // resolver hooks
+            hasGlobalName: resolver.hasGlobalName,
+
+            // transform hooks
+            onEmitNode: transform.emitNodeWithNotification,
+            onSubstituteNode: transform.emitNodeWithSubstitution,
+
+            // sourcemap hooks
+            onEmitSourceMapOfNode: sourceMap.emitNodeWithSourceMap,
+            onEmitSourceMapOfToken: sourceMap.emitTokenWithSourceMap,
+
+            // comment hooks
+            onEmitCommentsOfNode: comments.emitNodeWithComments,
+            onEmitDetachedCommentsOfNode: comments.emitBodyWithDetachedComments,
+            onEmitTrailingCommentsOfPosition: comments.emitTrailingCommentsOfPosition,
+
+            // emitter hooks
+            onEmitHelpers: emitHelpers,
+            onSetSourceFile: setSourceFile,
+        });
 
         // Emit each output file
         performance.mark("beforePrint");
-        forEachEmittedFile(host, emitFile, transformed, emitOnlyDtsFiles);
+        forEachEmittedFile(host, emitSourceFileOrBundle, transform.transformed, emitOnlyDtsFiles);
         performance.measure("printTime", "beforePrint");
 
         // Clean up emit nodes on parse tree
@@ -88,11 +72,11 @@ namespace ts {
             sourceMaps: sourceMapDataList
         };
 
-        function emitFile({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean) {
+        function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
             // Make sure not to write js file and source map file if any of them cannot be written
             if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit) {
                 if (!emitOnlyDtsFiles) {
-                    printFile(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
+                    printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle);
                 }
             }
             else {
@@ -100,7 +84,7 @@ namespace ts {
             }
 
             if (declarationFilePath) {
-                emitSkipped = writeDeclarationFile(declarationFilePath, getOriginalSourceFiles(sourceFiles), isBundledEmit, host, resolver, emitterDiagnostics, emitOnlyDtsFiles) || emitSkipped;
+                emitSkipped = writeDeclarationFile(declarationFilePath, getOriginalSourceFileOrBundle(sourceFileOrBundle), host, resolver, emitterDiagnostics, emitOnlyDtsFiles) || emitSkipped;
             }
 
             if (!emitSkipped && emittedFilesList) {
@@ -116,34 +100,32 @@ namespace ts {
             }
         }
 
-        function printFile(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {
-            sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
-            nodeIdToGeneratedName = [];
-            autoGeneratedIdToGeneratedName = [];
-            generatedNameSet = createMap<string>();
-            bundledHelpers = isBundledEmit ? createMap<boolean>() : undefined;
-            isOwnFileEmit = !isBundledEmit;
+        function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string, sourceFileOrBundle: SourceFile | Bundle) {
+            const bundle = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle : undefined;
+            const sourceFile = sourceFileOrBundle.kind === SyntaxKind.SourceFile ? sourceFileOrBundle : undefined;
+            const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
+            sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFileOrBundle);
 
-            // Emit helpers from all the files
-            if (isBundledEmit && moduleKind) {
-                for (const sourceFile of sourceFiles) {
-                    emitHelpers(sourceFile, /*isBundle*/ true);
-                }
+            if (bundle) {
+                bundledHelpers = createMap<boolean>();
+                isOwnFileEmit = false;
+                printer.printBundle(bundle);
+            }
+            else {
+                isOwnFileEmit = true;
+                printer.printFile(sourceFile);
             }
 
-            // Print each transformed source file.
-            forEach(sourceFiles, printSourceFile);
-
-            writeLine();
+            writer.writeLine();
 
             const sourceMappingURL = sourceMap.getSourceMappingURL();
             if (sourceMappingURL) {
-                write(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Sometimes tools can sometimes see this line as a source mapping url comment
+                writer.write(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Sometimes tools can sometimes see this line as a source mapping url comment
             }
 
             // Write the source map
             if (compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) {
-                writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(),  /*writeByteOrderMark*/ false, sourceFiles);
+                writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(), /*writeByteOrderMark*/ false, sourceFiles);
             }
 
             // Record source map data for the test harness.
@@ -159,2654 +141,57 @@ namespace ts {
             comments.reset();
             writer.reset();
 
-            tempFlags = TempFlags.Auto;
             currentSourceFile = undefined;
-            currentText = undefined;
+            bundledHelpers = undefined;
             isOwnFileEmit = false;
         }
 
-        function printSourceFile(node: SourceFile) {
+        function setSourceFile(node: SourceFile) {
             currentSourceFile = node;
-            currentText = node.text;
-            currentFileIdentifiers = node.identifiers;
             sourceMap.setSourceFile(node);
             comments.setSourceFile(node);
-            pipelineEmitWithNotification(EmitContext.SourceFile, node);
         }
 
-        /**
-         * Emits a node.
-         */
-        function emit(node: Node) {
-            pipelineEmitWithNotification(EmitContext.Unspecified, node);
-        }
-
-        /**
-         * Emits an IdentifierName.
-         */
-        function emitIdentifierName(node: Identifier) {
-            pipelineEmitWithNotification(EmitContext.IdentifierName, node);
-        }
-
-        /**
-         * Emits an expression node.
-         */
-        function emitExpression(node: Expression) {
-            pipelineEmitWithNotification(EmitContext.Expression, node);
-        }
-
-        /**
-         * Emits a node with possible notification.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called from printSourceFile, emit, emitExpression, or
-         * emitIdentifierName.
-         */
-        function pipelineEmitWithNotification(emitContext: EmitContext, node: Node) {
-            emitNodeWithNotification(emitContext, node, pipelineEmitWithComments);
-        }
-
-        /**
-         * Emits a node with comments.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitWithNotification.
-         */
-        function pipelineEmitWithComments(emitContext: EmitContext, node: Node) {
-            // Do not emit comments for SourceFile
-            if (emitContext === EmitContext.SourceFile) {
-                pipelineEmitWithSourceMap(emitContext, node);
-                return;
-            }
-
-            emitNodeWithComments(emitContext, node, pipelineEmitWithSourceMap);
-        }
-
-        /**
-         * Emits a node with source maps.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitWithComments.
-         */
-        function pipelineEmitWithSourceMap(emitContext: EmitContext, node: Node) {
-            // Do not emit source mappings for SourceFile or IdentifierName
-            if (emitContext === EmitContext.SourceFile
-                || emitContext === EmitContext.IdentifierName) {
-                pipelineEmitWithSubstitution(emitContext, node);
-                return;
-            }
-
-            emitNodeWithSourceMap(emitContext, node, pipelineEmitWithSubstitution);
-        }
-
-        /**
-         * Emits a node with possible substitution.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitWithSourceMap or
-         * pipelineEmitInUnspecifiedContext (when picking a more specific context).
-         */
-        function pipelineEmitWithSubstitution(emitContext: EmitContext, node: Node) {
-            emitNodeWithSubstitution(emitContext, node, pipelineEmitForContext);
-        }
-
-        /**
-         * Emits a node.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitWithSubstitution.
-         */
-        function pipelineEmitForContext(emitContext: EmitContext, node: Node): void {
-            switch (emitContext) {
-                case EmitContext.SourceFile: return pipelineEmitInSourceFileContext(node);
-                case EmitContext.IdentifierName: return pipelineEmitInIdentifierNameContext(node);
-                case EmitContext.Unspecified: return pipelineEmitInUnspecifiedContext(node);
-                case EmitContext.Expression: return pipelineEmitInExpressionContext(node);
-            }
-        }
-
-        /**
-         * Emits a node in the SourceFile EmitContext.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitForContext.
-         */
-        function pipelineEmitInSourceFileContext(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Top-level nodes
-                case SyntaxKind.SourceFile:
-                    return emitSourceFile(<SourceFile>node);
-            }
-        }
-
-        /**
-         * Emits a node in the IdentifierName EmitContext.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitForContext.
-         */
-        function pipelineEmitInIdentifierNameContext(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Identifiers
-                case SyntaxKind.Identifier:
-                    return emitIdentifier(<Identifier>node);
-            }
-        }
-
-        /**
-         * Emits a node in the Unspecified EmitContext.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitForContext.
-         */
-        function pipelineEmitInUnspecifiedContext(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Pseudo-literals
-                case SyntaxKind.TemplateHead:
-                case SyntaxKind.TemplateMiddle:
-                case SyntaxKind.TemplateTail:
-                    return emitLiteral(<LiteralExpression>node);
-
-                // Identifiers
-                case SyntaxKind.Identifier:
-                    return emitIdentifier(<Identifier>node);
-
-                // Reserved words
-                case SyntaxKind.ConstKeyword:
-                case SyntaxKind.DefaultKeyword:
-                case SyntaxKind.ExportKeyword:
-                case SyntaxKind.VoidKeyword:
-
-                // Strict mode reserved words
-                case SyntaxKind.PrivateKeyword:
-                case SyntaxKind.ProtectedKeyword:
-                case SyntaxKind.PublicKeyword:
-                case SyntaxKind.StaticKeyword:
-
-                // Contextual keywords
-                case SyntaxKind.AbstractKeyword:
-                case SyntaxKind.AsKeyword:
-                case SyntaxKind.AnyKeyword:
-                case SyntaxKind.AsyncKeyword:
-                case SyntaxKind.AwaitKeyword:
-                case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.ConstructorKeyword:
-                case SyntaxKind.DeclareKeyword:
-                case SyntaxKind.GetKeyword:
-                case SyntaxKind.IsKeyword:
-                case SyntaxKind.ModuleKeyword:
-                case SyntaxKind.NamespaceKeyword:
-                case SyntaxKind.NeverKeyword:
-                case SyntaxKind.ReadonlyKeyword:
-                case SyntaxKind.RequireKeyword:
-                case SyntaxKind.NumberKeyword:
-                case SyntaxKind.SetKeyword:
-                case SyntaxKind.StringKeyword:
-                case SyntaxKind.SymbolKeyword:
-                case SyntaxKind.TypeKeyword:
-                case SyntaxKind.UndefinedKeyword:
-                case SyntaxKind.FromKeyword:
-                case SyntaxKind.GlobalKeyword:
-                case SyntaxKind.OfKeyword:
-                    writeTokenText(kind);
-                    return;
-
-                // Parse tree nodes
-
-                // Names
-                case SyntaxKind.QualifiedName:
-                    return emitQualifiedName(<QualifiedName>node);
-                case SyntaxKind.ComputedPropertyName:
-                    return emitComputedPropertyName(<ComputedPropertyName>node);
-
-                // Signature elements
-                case SyntaxKind.TypeParameter:
-                    return emitTypeParameter(<TypeParameterDeclaration>node);
-                case SyntaxKind.Parameter:
-                    return emitParameter(<ParameterDeclaration>node);
-                case SyntaxKind.Decorator:
-                    return emitDecorator(<Decorator>node);
-
-                // Type members
-                case SyntaxKind.PropertySignature:
-                    return emitPropertySignature(<PropertySignature>node);
-                case SyntaxKind.PropertyDeclaration:
-                    return emitPropertyDeclaration(<PropertyDeclaration>node);
-                case SyntaxKind.MethodSignature:
-                    return emitMethodSignature(<MethodSignature>node);
-                case SyntaxKind.MethodDeclaration:
-                    return emitMethodDeclaration(<MethodDeclaration>node);
-                case SyntaxKind.Constructor:
-                    return emitConstructor(<ConstructorDeclaration>node);
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return emitAccessorDeclaration(<AccessorDeclaration>node);
-                case SyntaxKind.CallSignature:
-                    return emitCallSignature(<CallSignatureDeclaration>node);
-                case SyntaxKind.ConstructSignature:
-                    return emitConstructSignature(<ConstructSignatureDeclaration>node);
-                case SyntaxKind.IndexSignature:
-                    return emitIndexSignature(<IndexSignatureDeclaration>node);
-
-                // Types
-                case SyntaxKind.TypePredicate:
-                    return emitTypePredicate(<TypePredicateNode>node);
-                case SyntaxKind.TypeReference:
-                    return emitTypeReference(<TypeReferenceNode>node);
-                case SyntaxKind.FunctionType:
-                    return emitFunctionType(<FunctionTypeNode>node);
-                case SyntaxKind.ConstructorType:
-                    return emitConstructorType(<ConstructorTypeNode>node);
-                case SyntaxKind.TypeQuery:
-                    return emitTypeQuery(<TypeQueryNode>node);
-                case SyntaxKind.TypeLiteral:
-                    return emitTypeLiteral(<TypeLiteralNode>node);
-                case SyntaxKind.ArrayType:
-                    return emitArrayType(<ArrayTypeNode>node);
-                case SyntaxKind.TupleType:
-                    return emitTupleType(<TupleTypeNode>node);
-                case SyntaxKind.UnionType:
-                    return emitUnionType(<UnionTypeNode>node);
-                case SyntaxKind.IntersectionType:
-                    return emitIntersectionType(<IntersectionTypeNode>node);
-                case SyntaxKind.ParenthesizedType:
-                    return emitParenthesizedType(<ParenthesizedTypeNode>node);
-                case SyntaxKind.ExpressionWithTypeArguments:
-                    return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
-                case SyntaxKind.ThisType:
-                    return emitThisType();
-                case SyntaxKind.TypeOperator:
-                    return emitTypeOperator(<TypeOperatorNode>node);
-                case SyntaxKind.IndexedAccessType:
-                    return emitIndexedAccessType(<IndexedAccessTypeNode>node);
-                case SyntaxKind.MappedType:
-                    return emitMappedType(<MappedTypeNode>node);
-                case SyntaxKind.LiteralType:
-                    return emitLiteralType(<LiteralTypeNode>node);
-
-                // Binding patterns
-                case SyntaxKind.ObjectBindingPattern:
-                    return emitObjectBindingPattern(<ObjectBindingPattern>node);
-                case SyntaxKind.ArrayBindingPattern:
-                    return emitArrayBindingPattern(<ArrayBindingPattern>node);
-                case SyntaxKind.BindingElement:
-                    return emitBindingElement(<BindingElement>node);
-
-                // Misc
-                case SyntaxKind.TemplateSpan:
-                    return emitTemplateSpan(<TemplateSpan>node);
-                case SyntaxKind.SemicolonClassElement:
-                    return emitSemicolonClassElement();
-
-                // Statements
-                case SyntaxKind.Block:
-                    return emitBlock(<Block>node);
-                case SyntaxKind.VariableStatement:
-                    return emitVariableStatement(<VariableStatement>node);
-                case SyntaxKind.EmptyStatement:
-                    return emitEmptyStatement();
-                case SyntaxKind.ExpressionStatement:
-                    return emitExpressionStatement(<ExpressionStatement>node);
-                case SyntaxKind.IfStatement:
-                    return emitIfStatement(<IfStatement>node);
-                case SyntaxKind.DoStatement:
-                    return emitDoStatement(<DoStatement>node);
-                case SyntaxKind.WhileStatement:
-                    return emitWhileStatement(<WhileStatement>node);
-                case SyntaxKind.ForStatement:
-                    return emitForStatement(<ForStatement>node);
-                case SyntaxKind.ForInStatement:
-                    return emitForInStatement(<ForInStatement>node);
-                case SyntaxKind.ForOfStatement:
-                    return emitForOfStatement(<ForOfStatement>node);
-                case SyntaxKind.ContinueStatement:
-                    return emitContinueStatement(<ContinueStatement>node);
-                case SyntaxKind.BreakStatement:
-                    return emitBreakStatement(<BreakStatement>node);
-                case SyntaxKind.ReturnStatement:
-                    return emitReturnStatement(<ReturnStatement>node);
-                case SyntaxKind.WithStatement:
-                    return emitWithStatement(<WithStatement>node);
-                case SyntaxKind.SwitchStatement:
-                    return emitSwitchStatement(<SwitchStatement>node);
-                case SyntaxKind.LabeledStatement:
-                    return emitLabeledStatement(<LabeledStatement>node);
-                case SyntaxKind.ThrowStatement:
-                    return emitThrowStatement(<ThrowStatement>node);
-                case SyntaxKind.TryStatement:
-                    return emitTryStatement(<TryStatement>node);
-                case SyntaxKind.DebuggerStatement:
-                    return emitDebuggerStatement(<DebuggerStatement>node);
-
-                // Declarations
-                case SyntaxKind.VariableDeclaration:
-                    return emitVariableDeclaration(<VariableDeclaration>node);
-                case SyntaxKind.VariableDeclarationList:
-                    return emitVariableDeclarationList(<VariableDeclarationList>node);
-                case SyntaxKind.FunctionDeclaration:
-                    return emitFunctionDeclaration(<FunctionDeclaration>node);
-                case SyntaxKind.ClassDeclaration:
-                    return emitClassDeclaration(<ClassDeclaration>node);
-                case SyntaxKind.InterfaceDeclaration:
-                    return emitInterfaceDeclaration(<InterfaceDeclaration>node);
-                case SyntaxKind.TypeAliasDeclaration:
-                    return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);
-                case SyntaxKind.EnumDeclaration:
-                    return emitEnumDeclaration(<EnumDeclaration>node);
-                case SyntaxKind.ModuleDeclaration:
-                    return emitModuleDeclaration(<ModuleDeclaration>node);
-                case SyntaxKind.ModuleBlock:
-                    return emitModuleBlock(<ModuleBlock>node);
-                case SyntaxKind.CaseBlock:
-                    return emitCaseBlock(<CaseBlock>node);
-                case SyntaxKind.ImportEqualsDeclaration:
-                    return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
-                case SyntaxKind.ImportDeclaration:
-                    return emitImportDeclaration(<ImportDeclaration>node);
-                case SyntaxKind.ImportClause:
-                    return emitImportClause(<ImportClause>node);
-                case SyntaxKind.NamespaceImport:
-                    return emitNamespaceImport(<NamespaceImport>node);
-                case SyntaxKind.NamedImports:
-                    return emitNamedImports(<NamedImports>node);
-                case SyntaxKind.ImportSpecifier:
-                    return emitImportSpecifier(<ImportSpecifier>node);
-                case SyntaxKind.ExportAssignment:
-                    return emitExportAssignment(<ExportAssignment>node);
-                case SyntaxKind.ExportDeclaration:
-                    return emitExportDeclaration(<ExportDeclaration>node);
-                case SyntaxKind.NamedExports:
-                    return emitNamedExports(<NamedExports>node);
-                case SyntaxKind.ExportSpecifier:
-                    return emitExportSpecifier(<ExportSpecifier>node);
-                case SyntaxKind.MissingDeclaration:
-                    return;
-
-                // Module references
-                case SyntaxKind.ExternalModuleReference:
-                    return emitExternalModuleReference(<ExternalModuleReference>node);
-
-                // JSX (non-expression)
-                case SyntaxKind.JsxText:
-                    return emitJsxText(<JsxText>node);
-                case SyntaxKind.JsxOpeningElement:
-                    return emitJsxOpeningElement(<JsxOpeningElement>node);
-                case SyntaxKind.JsxClosingElement:
-                    return emitJsxClosingElement(<JsxClosingElement>node);
-                case SyntaxKind.JsxAttribute:
-                    return emitJsxAttribute(<JsxAttribute>node);
-                case SyntaxKind.JsxSpreadAttribute:
-                    return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);
-                case SyntaxKind.JsxExpression:
-                    return emitJsxExpression(<JsxExpression>node);
-
-                // Clauses
-                case SyntaxKind.CaseClause:
-                    return emitCaseClause(<CaseClause>node);
-                case SyntaxKind.DefaultClause:
-                    return emitDefaultClause(<DefaultClause>node);
-                case SyntaxKind.HeritageClause:
-                    return emitHeritageClause(<HeritageClause>node);
-                case SyntaxKind.CatchClause:
-                    return emitCatchClause(<CatchClause>node);
-
-                // Property assignments
-                case SyntaxKind.PropertyAssignment:
-                    return emitPropertyAssignment(<PropertyAssignment>node);
-                case SyntaxKind.ShorthandPropertyAssignment:
-                    return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);
-                case SyntaxKind.SpreadAssignment:
-                    return emitSpreadAssignment(node as SpreadAssignment);
-
-                // Enum
-                case SyntaxKind.EnumMember:
-                    return emitEnumMember(<EnumMember>node);
-
-                // JSDoc nodes (ignored)
-                // Transformation nodes (ignored)
-            }
-
-            // If the node is an expression, try to emit it as an expression with
-            // substitution.
-            if (isExpression(node)) {
-                return pipelineEmitWithSubstitution(EmitContext.Expression, node);
-            }
-        }
-
-        /**
-         * Emits a node in the Expression EmitContext.
-         *
-         * NOTE: Do not call this method directly. It is part of the emit pipeline
-         * and should only be called indirectly from pipelineEmitForContext.
-         */
-        function pipelineEmitInExpressionContext(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Literals
-                case SyntaxKind.NumericLiteral:
-                    return emitNumericLiteral(<NumericLiteral>node);
-
-                case SyntaxKind.StringLiteral:
-                case SyntaxKind.RegularExpressionLiteral:
-                case SyntaxKind.NoSubstitutionTemplateLiteral:
-                    return emitLiteral(<LiteralExpression>node);
-
-                // Identifiers
-                case SyntaxKind.Identifier:
-                    return emitIdentifier(<Identifier>node);
-
-                // Reserved words
-                case SyntaxKind.FalseKeyword:
-                case SyntaxKind.NullKeyword:
-                case SyntaxKind.SuperKeyword:
-                case SyntaxKind.TrueKeyword:
-                case SyntaxKind.ThisKeyword:
-                    writeTokenText(kind);
-                    return;
-
-                // Expressions
-                case SyntaxKind.ArrayLiteralExpression:
-                    return emitArrayLiteralExpression(<ArrayLiteralExpression>node);
-                case SyntaxKind.ObjectLiteralExpression:
-                    return emitObjectLiteralExpression(<ObjectLiteralExpression>node);
-                case SyntaxKind.PropertyAccessExpression:
-                    return emitPropertyAccessExpression(<PropertyAccessExpression>node);
-                case SyntaxKind.ElementAccessExpression:
-                    return emitElementAccessExpression(<ElementAccessExpression>node);
-                case SyntaxKind.CallExpression:
-                    return emitCallExpression(<CallExpression>node);
-                case SyntaxKind.NewExpression:
-                    return emitNewExpression(<NewExpression>node);
-                case SyntaxKind.TaggedTemplateExpression:
-                    return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
-                case SyntaxKind.TypeAssertionExpression:
-                    return emitTypeAssertionExpression(<TypeAssertion>node);
-                case SyntaxKind.ParenthesizedExpression:
-                    return emitParenthesizedExpression(<ParenthesizedExpression>node);
-                case SyntaxKind.FunctionExpression:
-                    return emitFunctionExpression(<FunctionExpression>node);
-                case SyntaxKind.ArrowFunction:
-                    return emitArrowFunction(<ArrowFunction>node);
-                case SyntaxKind.DeleteExpression:
-                    return emitDeleteExpression(<DeleteExpression>node);
-                case SyntaxKind.TypeOfExpression:
-                    return emitTypeOfExpression(<TypeOfExpression>node);
-                case SyntaxKind.VoidExpression:
-                    return emitVoidExpression(<VoidExpression>node);
-                case SyntaxKind.AwaitExpression:
-                    return emitAwaitExpression(<AwaitExpression>node);
-                case SyntaxKind.PrefixUnaryExpression:
-                    return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);
-                case SyntaxKind.PostfixUnaryExpression:
-                    return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);
-                case SyntaxKind.BinaryExpression:
-                    return emitBinaryExpression(<BinaryExpression>node);
-                case SyntaxKind.ConditionalExpression:
-                    return emitConditionalExpression(<ConditionalExpression>node);
-                case SyntaxKind.TemplateExpression:
-                    return emitTemplateExpression(<TemplateExpression>node);
-                case SyntaxKind.YieldExpression:
-                    return emitYieldExpression(<YieldExpression>node);
-                case SyntaxKind.SpreadElement:
-                    return emitSpreadExpression(<SpreadElement>node);
-                case SyntaxKind.ClassExpression:
-                    return emitClassExpression(<ClassExpression>node);
-                case SyntaxKind.OmittedExpression:
-                    return;
-                case SyntaxKind.AsExpression:
-                    return emitAsExpression(<AsExpression>node);
-                case SyntaxKind.NonNullExpression:
-                    return emitNonNullExpression(<NonNullExpression>node);
-                case SyntaxKind.MetaProperty:
-                    return emitMetaProperty(<MetaProperty>node);
-
-                // JSX
-                case SyntaxKind.JsxElement:
-                    return emitJsxElement(<JsxElement>node);
-                case SyntaxKind.JsxSelfClosingElement:
-                    return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);
-
-                // Transformation nodes
-                case SyntaxKind.PartiallyEmittedExpression:
-                    return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
-            }
-        }
-
-        //
-        // Literals/Pseudo-literals
-        //
-
-        // SyntaxKind.NumericLiteral
-        function emitNumericLiteral(node: NumericLiteral) {
-            emitLiteral(node);
-            if (node.trailingComment) {
-                write(` /*${node.trailingComment}*/`);
-            }
-        }
-
-        // SyntaxKind.StringLiteral
-        // SyntaxKind.RegularExpressionLiteral
-        // SyntaxKind.NoSubstitutionTemplateLiteral
-        // SyntaxKind.TemplateHead
-        // SyntaxKind.TemplateMiddle
-        // SyntaxKind.TemplateTail
-        function emitLiteral(node: LiteralLikeNode) {
-            const text = getLiteralTextOfNode(node);
-            if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap)
-                && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
-                writer.writeLiteral(text);
-            }
-            else {
-                write(text);
-            }
-        }
-
-        //
-        // Identifiers
-        //
-
-        function emitIdentifier(node: Identifier) {
-            write(getTextOfNode(node, /*includeTrivia*/ false));
-        }
-
-        //
-        // Names
-        //
-
-        function emitQualifiedName(node: QualifiedName) {
-            emitEntityName(node.left);
-            write(".");
-            emit(node.right);
-        }
-
-        function emitEntityName(node: EntityName) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        function emitComputedPropertyName(node: ComputedPropertyName) {
-            write("[");
-            emitExpression(node.expression);
-            write("]");
-        }
-
-        //
-        // Signature elements
-        //
-
-        function emitTypeParameter(node: TypeParameterDeclaration) {
-            emit(node.name);
-            emitWithPrefix(" extends ", node.constraint);
-        }
-
-        function emitParameter(node: ParameterDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            writeIfPresent(node.dotDotDotToken, "...");
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitExpressionWithPrefix(" = ", node.initializer);
-            emitWithPrefix(": ", node.type);
-        }
-
-        function emitDecorator(decorator: Decorator) {
-            write("@");
-            emitExpression(decorator.expression);
-        }
-
-        //
-        // Type members
-        //
-
-        function emitPropertySignature(node: PropertySignature) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitPropertyDeclaration(node: PropertyDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            emitWithPrefix(": ", node.type);
-            emitExpressionWithPrefix(" = ", node.initializer);
-            write(";");
-        }
-
-        function emitMethodSignature(node: MethodSignature) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitMethodDeclaration(node: MethodDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            writeIfPresent(node.asteriskToken, "*");
-            emit(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitConstructor(node: ConstructorDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("constructor");
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitAccessorDeclaration(node: AccessorDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write(node.kind === SyntaxKind.GetAccessor ? "get " : "set ");
-            emit(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitCallSignature(node: CallSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitConstructSignature(node: ConstructSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("new ");
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitIndexSignature(node: IndexSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitParametersForIndexSignature(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitSemicolonClassElement() {
-            write(";");
-        }
-
-        //
-        // Types
-        //
-
-        function emitTypePredicate(node: TypePredicateNode) {
-            emit(node.parameterName);
-            write(" is ");
-            emit(node.type);
-        }
-
-        function emitTypeReference(node: TypeReferenceNode) {
-            emit(node.typeName);
-            emitTypeArguments(node, node.typeArguments);
-        }
-
-        function emitFunctionType(node: FunctionTypeNode) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            write(" => ");
-            emit(node.type);
-        }
-
-        function emitConstructorType(node: ConstructorTypeNode) {
-            write("new ");
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            write(" => ");
-            emit(node.type);
-        }
-
-        function emitTypeQuery(node: TypeQueryNode) {
-            write("typeof ");
-            emit(node.exprName);
-        }
-
-        function emitTypeLiteral(node: TypeLiteralNode) {
-            write("{");
-            emitList(node, node.members, ListFormat.TypeLiteralMembers);
-            write("}");
-        }
-
-        function emitArrayType(node: ArrayTypeNode) {
-            emit(node.elementType);
-            write("[]");
-        }
-
-        function emitTupleType(node: TupleTypeNode) {
-            write("[");
-            emitList(node, node.elementTypes, ListFormat.TupleTypeElements);
-            write("]");
-        }
-
-        function emitUnionType(node: UnionTypeNode) {
-            emitList(node, node.types, ListFormat.UnionTypeConstituents);
-        }
-
-        function emitIntersectionType(node: IntersectionTypeNode) {
-            emitList(node, node.types, ListFormat.IntersectionTypeConstituents);
-        }
-
-        function emitParenthesizedType(node: ParenthesizedTypeNode) {
-            write("(");
-            emit(node.type);
-            write(")");
-        }
-
-        function emitThisType() {
-            write("this");
-        }
-
-        function emitTypeOperator(node: TypeOperatorNode) {
-            writeTokenText(node.operator);
-            write(" ");
-            emit(node.type);
-        }
-
-        function emitIndexedAccessType(node: IndexedAccessTypeNode) {
-            emit(node.objectType);
-            write("[");
-            emit(node.indexType);
-            write("]");
-        }
-
-        function emitMappedType(node: MappedTypeNode) {
-            write("{");
-            writeLine();
-            increaseIndent();
-            if (node.readonlyToken) {
-                write("readonly ");
-            }
-            write("[");
-            emit(node.typeParameter.name);
-            write(" in ");
-            emit(node.typeParameter.constraint);
-            write("]");
-            if (node.questionToken) {
-                write("?");
-            }
-            write(": ");
-            emit(node.type);
-            write(";");
-            writeLine();
-            decreaseIndent();
-            write("}");
-        }
-
-        function emitLiteralType(node: LiteralTypeNode) {
-            emitExpression(node.literal);
-        }
-
-        //
-        // Binding patterns
-        //
-
-        function emitObjectBindingPattern(node: ObjectBindingPattern) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("{}");
-            }
-            else {
-                write("{");
-                emitList(node, elements, ListFormat.ObjectBindingPatternElements);
-                write("}");
-            }
-        }
-
-        function emitArrayBindingPattern(node: ArrayBindingPattern) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("[]");
-            }
-            else {
-                write("[");
-                emitList(node, node.elements, ListFormat.ArrayBindingPatternElements);
-                write("]");
-            }
-        }
-
-        function emitBindingElement(node: BindingElement) {
-            emitWithSuffix(node.propertyName, ": ");
-            writeIfPresent(node.dotDotDotToken, "...");
-            emit(node.name);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        //
-        // Expressions
-        //
-
-        function emitArrayLiteralExpression(node: ArrayLiteralExpression) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("[]");
-            }
-            else {
-                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
-                emitExpressionList(node, elements, ListFormat.ArrayLiteralExpressionElements | preferNewLine);
-            }
-        }
-
-        function emitObjectLiteralExpression(node: ObjectLiteralExpression) {
-            const properties = node.properties;
-            if (properties.length === 0) {
-                write("{}");
-            }
-            else {
-                const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-                if (indentedFlag) {
-                    increaseIndent();
-                }
-
-                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
-                const allowTrailingComma = languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None;
-                emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine);
-
-                if (indentedFlag) {
-                    decreaseIndent();
-                }
-            }
-        }
-
-        function emitPropertyAccessExpression(node: PropertyAccessExpression) {
-            let indentBeforeDot = false;
-            let indentAfterDot = false;
-            if (!(getEmitFlags(node) & EmitFlags.NoIndentation)) {
-                const dotRangeStart = node.expression.end;
-                const dotRangeEnd = skipTrivia(currentText, node.expression.end) + 1;
-                const dotToken = <Node>{ kind: SyntaxKind.DotToken, pos: dotRangeStart, end: dotRangeEnd };
-                indentBeforeDot = needsIndentation(node, node.expression, dotToken);
-                indentAfterDot = needsIndentation(node, dotToken, node.name);
-            }
-
-            emitExpression(node.expression);
-            increaseIndentIf(indentBeforeDot);
-
-            const shouldEmitDotDot = !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
-            write(shouldEmitDotDot ? ".." : ".");
-
-            increaseIndentIf(indentAfterDot);
-            emit(node.name);
-            decreaseIndentIf(indentBeforeDot, indentAfterDot);
-        }
-
-        // 1..toString is a valid property access, emit a dot after the literal
-        // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal
-        function needsDotDotForPropertyAccess(expression: Expression) {
-            if (expression.kind === SyntaxKind.NumericLiteral) {
-                // check if numeric literal is a decimal literal that was originally written with a dot
-                const text = getLiteralTextOfNode(<LiteralExpression>expression);
-                return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None
-                    && !(<LiteralExpression>expression).isOctalLiteral
-                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
-            }
-            else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
-                // check if constant enum value is integer
-                const constantValue = getConstantValue(expression);
-                // isFinite handles cases when constantValue is undefined
-                return isFinite(constantValue)
-                    && Math.floor(constantValue) === constantValue
-                    && compilerOptions.removeComments;
-            }
-        }
-
-        function emitElementAccessExpression(node: ElementAccessExpression) {
-            emitExpression(node.expression);
-            write("[");
-            emitExpression(node.argumentExpression);
-            write("]");
-        }
-
-        function emitCallExpression(node: CallExpression) {
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-            emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
-        }
-
-        function emitNewExpression(node: NewExpression) {
-            write("new ");
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-            emitExpressionList(node, node.arguments, ListFormat.NewExpressionArguments);
-        }
-
-        function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
-            emitExpression(node.tag);
-            write(" ");
-            emitExpression(node.template);
-        }
-
-        function emitTypeAssertionExpression(node: TypeAssertion) {
-            if (node.type) {
-                write("<");
-                emit(node.type);
-                write(">");
-            }
-
-            emitExpression(node.expression);
-        }
-
-        function emitParenthesizedExpression(node: ParenthesizedExpression) {
-            write("(");
-            emitExpression(node.expression);
-            write(")");
-        }
-
-        function emitFunctionExpression(node: FunctionExpression) {
-            emitFunctionDeclarationOrExpression(node);
-        }
-
-        function emitArrowFunction(node: ArrowFunction) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitSignatureAndBody(node, emitArrowFunctionHead);
-        }
-
-        function emitArrowFunctionHead(node: ArrowFunction) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(" =>");
-        }
-
-        function emitDeleteExpression(node: DeleteExpression) {
-            write("delete ");
-            emitExpression(node.expression);
-        }
-
-        function emitTypeOfExpression(node: TypeOfExpression) {
-            write("typeof ");
-            emitExpression(node.expression);
-        }
-
-        function emitVoidExpression(node: VoidExpression) {
-            write("void ");
-            emitExpression(node.expression);
-        }
-
-        function emitAwaitExpression(node: AwaitExpression) {
-            write("await ");
-            emitExpression(node.expression);
-        }
-
-        function emitPrefixUnaryExpression(node: PrefixUnaryExpression) {
-            writeTokenText(node.operator);
-            if (shouldEmitWhitespaceBeforeOperand(node)) {
-                write(" ");
-            }
-            emitExpression(node.operand);
-        }
-
-        function shouldEmitWhitespaceBeforeOperand(node: PrefixUnaryExpression) {
-            // In some cases, we need to emit a space between the operator and the operand. One obvious case
-            // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
-            // and minus expressions in certain cases. Specifically, consider the following two cases (parens
-            // are just for clarity of exposition, and not part of the source code):
-            //
-            //  (+(+1))
-            //  (+(++1))
-            //
-            // We need to emit a space in both cases. In the first case, the absence of a space will make
-            // the resulting expression a prefix increment operation. And in the second, it will make the resulting
-            // expression a prefix increment whose operand is a plus expression - (++(+x))
-            // The same is true of minus of course.
-            const operand = node.operand;
-            return operand.kind === SyntaxKind.PrefixUnaryExpression
-                && ((node.operator === SyntaxKind.PlusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusPlusToken))
-                || (node.operator === SyntaxKind.MinusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusMinusToken)));
-        }
-
-        function emitPostfixUnaryExpression(node: PostfixUnaryExpression) {
-            emitExpression(node.operand);
-            writeTokenText(node.operator);
-        }
-
-        function emitBinaryExpression(node: BinaryExpression) {
-            const isCommaOperator = node.operatorToken.kind !== SyntaxKind.CommaToken;
-            const indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken);
-            const indentAfterOperator = needsIndentation(node, node.operatorToken, node.right);
-
-            emitExpression(node.left);
-            increaseIndentIf(indentBeforeOperator, isCommaOperator ? " " : undefined);
-            writeTokenText(node.operatorToken.kind);
-            increaseIndentIf(indentAfterOperator, " ");
-            emitExpression(node.right);
-            decreaseIndentIf(indentBeforeOperator, indentAfterOperator);
-        }
-
-        function emitConditionalExpression(node: ConditionalExpression) {
-            const indentBeforeQuestion = needsIndentation(node, node.condition, node.questionToken);
-            const indentAfterQuestion = needsIndentation(node, node.questionToken, node.whenTrue);
-            const indentBeforeColon = needsIndentation(node, node.whenTrue, node.colonToken);
-            const indentAfterColon = needsIndentation(node, node.colonToken, node.whenFalse);
-
-            emitExpression(node.condition);
-            increaseIndentIf(indentBeforeQuestion, " ");
-            write("?");
-            increaseIndentIf(indentAfterQuestion, " ");
-            emitExpression(node.whenTrue);
-            decreaseIndentIf(indentBeforeQuestion, indentAfterQuestion);
-
-            increaseIndentIf(indentBeforeColon, " ");
-            write(":");
-            increaseIndentIf(indentAfterColon, " ");
-            emitExpression(node.whenFalse);
-            decreaseIndentIf(indentBeforeColon, indentAfterColon);
-        }
-
-        function emitTemplateExpression(node: TemplateExpression) {
-            emit(node.head);
-            emitList(node, node.templateSpans, ListFormat.TemplateExpressionSpans);
-        }
-
-        function emitYieldExpression(node: YieldExpression) {
-            write(node.asteriskToken ? "yield*" : "yield");
-            emitExpressionWithPrefix(" ", node.expression);
-        }
-
-        function emitSpreadExpression(node: SpreadElement) {
-            write("...");
-            emitExpression(node.expression);
-        }
-
-        function emitClassExpression(node: ClassExpression) {
-            emitClassDeclarationOrExpression(node);
-        }
-
-        function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-        }
-
-        function emitAsExpression(node: AsExpression) {
-            emitExpression(node.expression);
-            if (node.type) {
-                write(" as ");
-                emit(node.type);
-            }
-        }
-
-        function emitNonNullExpression(node: NonNullExpression) {
-            emitExpression(node.expression);
-            write("!");
-        }
-
-        function emitMetaProperty(node: MetaProperty) {
-            writeToken(node.keywordToken, node.pos);
-            write(".");
-            emit(node.name);
-        }
-
-        //
-        // Misc
-        //
-
-        function emitTemplateSpan(node: TemplateSpan) {
-            emitExpression(node.expression);
-            emit(node.literal);
-        }
-
-        //
-        // Statements
-        //
-
-        function emitBlock(node: Block) {
-            if (isSingleLineEmptyBlock(node)) {
-                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
-                write(" ");
-                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
-            }
-            else {
-                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
-                emitBlockStatements(node);
-                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
-            }
-        }
-
-        function emitBlockStatements(node: BlockLike) {
-            if (getEmitFlags(node) & EmitFlags.SingleLine) {
-                emitList(node, node.statements, ListFormat.SingleLineBlockStatements);
-            }
-            else {
-                emitList(node, node.statements, ListFormat.MultiLineBlockStatements);
-            }
-        }
-
-        function emitVariableStatement(node: VariableStatement) {
-            emitModifiers(node, node.modifiers);
-            emit(node.declarationList);
-            write(";");
-        }
-
-        function emitEmptyStatement() {
-            write(";");
-        }
-
-        function emitExpressionStatement(node: ExpressionStatement) {
-            emitExpression(node.expression);
-            write(";");
-        }
-
-        function emitIfStatement(node: IfStatement) {
-            const openParenPos = writeToken(SyntaxKind.IfKeyword, node.pos, node);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos, node);
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end, node);
-            emitEmbeddedStatement(node, node.thenStatement);
-            if (node.elseStatement) {
-                writeLineOrSpace(node);
-                writeToken(SyntaxKind.ElseKeyword, node.thenStatement.end, node);
-                if (node.elseStatement.kind === SyntaxKind.IfStatement) {
-                    write(" ");
-                    emit(node.elseStatement);
-                }
-                else {
-                    emitEmbeddedStatement(node, node.elseStatement);
-                }
-            }
-        }
-
-        function emitDoStatement(node: DoStatement) {
-            write("do");
-            emitEmbeddedStatement(node, node.statement);
-            if (isBlock(node.statement)) {
-                write(" ");
-            }
-            else {
-                writeLineOrSpace(node);
-            }
-
-            write("while (");
-            emitExpression(node.expression);
-            write(");");
-        }
-
-        function emitWhileStatement(node: WhileStatement) {
-            write("while (");
-            emitExpression(node.expression);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForStatement(node: ForStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos, /*contextNode*/ node);
-            emitForBinding(node.initializer);
-            write(";");
-            emitExpressionWithPrefix(" ", node.condition);
-            write(";");
-            emitExpressionWithPrefix(" ", node.incrementor);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForInStatement(node: ForInStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitForBinding(node.initializer);
-            write(" in ");
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForOfStatement(node: ForOfStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitForBinding(node.initializer);
-            write(" of ");
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForBinding(node: VariableDeclarationList | Expression) {
-            if (node !== undefined) {
-                if (node.kind === SyntaxKind.VariableDeclarationList) {
-                    emit(node);
-                }
-                else {
-                    emitExpression(<Expression>node);
-                }
-            }
-        }
-
-        function emitContinueStatement(node: ContinueStatement) {
-            writeToken(SyntaxKind.ContinueKeyword, node.pos);
-            emitWithPrefix(" ", node.label);
-            write(";");
-        }
-
-        function emitBreakStatement(node: BreakStatement) {
-            writeToken(SyntaxKind.BreakKeyword, node.pos);
-            emitWithPrefix(" ", node.label);
-            write(";");
-        }
-
-        function emitReturnStatement(node: ReturnStatement) {
-            writeToken(SyntaxKind.ReturnKeyword, node.pos, /*contextNode*/ node);
-            emitExpressionWithPrefix(" ", node.expression);
-            write(";");
-        }
-
-        function emitWithStatement(node: WithStatement) {
-            write("with (");
-            emitExpression(node.expression);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitSwitchStatement(node: SwitchStatement) {
-            const openParenPos = writeToken(SyntaxKind.SwitchKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            write(" ");
-            emit(node.caseBlock);
-        }
-
-        function emitLabeledStatement(node: LabeledStatement) {
-            emit(node.label);
-            write(": ");
-            emit(node.statement);
-        }
-
-        function emitThrowStatement(node: ThrowStatement) {
-            write("throw");
-            emitExpressionWithPrefix(" ", node.expression);
-            write(";");
-        }
-
-        function emitTryStatement(node: TryStatement) {
-            write("try ");
-            emit(node.tryBlock);
-            if (node.catchClause) {
-                writeLineOrSpace(node);
-                emit(node.catchClause);
-            }
-            if (node.finallyBlock) {
-                writeLineOrSpace(node);
-                write("finally ");
-                emit(node.finallyBlock);
-            }
-        }
-
-        function emitDebuggerStatement(node: DebuggerStatement) {
-            writeToken(SyntaxKind.DebuggerKeyword, node.pos);
-            write(";");
-        }
-
-        //
-        // Declarations
-        //
-
-        function emitVariableDeclaration(node: VariableDeclaration) {
-            emit(node.name);
-            emitWithPrefix(": ", node.type);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        function emitVariableDeclarationList(node: VariableDeclarationList) {
-            write(isLet(node) ? "let " : isConst(node) ? "const " : "var ");
-            emitList(node, node.declarations, ListFormat.VariableDeclarationList);
-        }
-
-        function emitFunctionDeclaration(node: FunctionDeclaration) {
-            emitFunctionDeclarationOrExpression(node);
-        }
-
-        function emitFunctionDeclarationOrExpression(node: FunctionDeclaration | FunctionExpression) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write(node.asteriskToken ? "function* " : "function ");
-            emitIdentifierName(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitSignatureAndBody(node: FunctionLikeDeclaration, emitSignatureHead: (node: SignatureDeclaration) => void) {
-            const body = node.body;
-            if (body) {
-                if (isBlock(body)) {
-                    const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-                    if (indentedFlag) {
-                        increaseIndent();
-                    }
-
-                    if (getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
-                        emitSignatureHead(node);
-                        emitBlockFunctionBody(body);
-                    }
-                    else {
-                        const savedTempFlags = tempFlags;
-                        tempFlags = 0;
-                        emitSignatureHead(node);
-                        emitBlockFunctionBody(body);
-                        tempFlags = savedTempFlags;
-                    }
-
-                    if (indentedFlag) {
-                        decreaseIndent();
-                    }
-                }
-                else {
-                    emitSignatureHead(node);
-                    write(" ");
-                    emitExpression(body);
-                }
-            }
-            else {
-                emitSignatureHead(node);
-                write(";");
-            }
-
-        }
-
-        function emitSignatureHead(node: FunctionDeclaration | FunctionExpression | MethodDeclaration | AccessorDeclaration | ConstructorDeclaration) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-        }
-
-        function shouldEmitBlockFunctionBodyOnSingleLine(body: Block) {
-            // We must emit a function body as a single-line body in the following case:
-            // * The body has NodeEmitFlags.SingleLine specified.
-
-            // We must emit a function body as a multi-line body in the following cases:
-            // * The body is explicitly marked as multi-line.
-            // * A non-synthesized body's start and end position are on different lines.
-            // * Any statement in the body starts on a new line.
-
-            if (getEmitFlags(body) & EmitFlags.SingleLine) {
-                return true;
-            }
-
-            if (body.multiLine) {
-                return false;
-            }
-
-            if (!nodeIsSynthesized(body) && !rangeIsOnSingleLine(body, currentSourceFile)) {
-                return false;
-            }
-
-            if (shouldWriteLeadingLineTerminator(body, body.statements, ListFormat.PreserveLines)
-                || shouldWriteClosingLineTerminator(body, body.statements, ListFormat.PreserveLines)) {
-                return false;
-            }
-
-            let previousStatement: Statement;
-            for (const statement of body.statements) {
-                if (shouldWriteSeparatingLineTerminator(previousStatement, statement, ListFormat.PreserveLines)) {
-                    return false;
-                }
-
-                previousStatement = statement;
-            }
-
-            return true;
-        }
-
-        function emitBlockFunctionBody(body: Block) {
-            write(" {");
-            increaseIndent();
-
-            emitBodyWithDetachedComments(body, body.statements,
-                shouldEmitBlockFunctionBodyOnSingleLine(body)
-                    ? emitBlockFunctionBodyOnSingleLine
-                    : emitBlockFunctionBodyWorker);
-
-            decreaseIndent();
-            writeToken(SyntaxKind.CloseBraceToken, body.statements.end, body);
-        }
-
-        function emitBlockFunctionBodyOnSingleLine(body: Block) {
-            emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true);
-        }
-
-        function emitBlockFunctionBodyWorker(body: Block, emitBlockFunctionBodyOnSingleLine?: boolean) {
-            // Emit all the prologue directives (like "use strict").
-            const statementOffset = emitPrologueDirectives(body.statements, /*startWithNewLine*/ true);
-            const helpersEmitted = emitHelpers(body);
-
-            if (statementOffset === 0 && !helpersEmitted && emitBlockFunctionBodyOnSingleLine) {
-                decreaseIndent();
-                emitList(body, body.statements, ListFormat.SingleLineFunctionBodyStatements);
-                increaseIndent();
-            }
-            else {
-                emitList(body, body.statements, ListFormat.MultiLineFunctionBodyStatements, statementOffset);
-            }
-        }
-
-        function emitClassDeclaration(node: ClassDeclaration) {
-            emitClassDeclarationOrExpression(node);
-        }
-
-        function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("class");
-            emitNodeWithPrefix(" ", node.name, emitIdentifierName);
-
-            const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-            if (indentedFlag) {
-                increaseIndent();
-            }
-
-            emitTypeParameters(node, node.typeParameters);
-            emitList(node, node.heritageClauses, ListFormat.ClassHeritageClauses);
-
-            const savedTempFlags = tempFlags;
-            tempFlags = 0;
-
-            write(" {");
-            emitList(node, node.members, ListFormat.ClassMembers);
-            write("}");
-
-            if (indentedFlag) {
-                decreaseIndent();
-            }
-
-            tempFlags = savedTempFlags;
-        }
-
-        function emitInterfaceDeclaration(node: InterfaceDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("interface ");
-            emit(node.name);
-            emitTypeParameters(node, node.typeParameters);
-            emitList(node, node.heritageClauses, ListFormat.HeritageClauses);
-            write(" {");
-            emitList(node, node.members, ListFormat.InterfaceMembers);
-            write("}");
-        }
-
-        function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("type ");
-            emit(node.name);
-            emitTypeParameters(node, node.typeParameters);
-            write(" = ");
-            emit(node.type);
-            write(";");
-        }
-
-        function emitEnumDeclaration(node: EnumDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("enum ");
-            emit(node.name);
-
-            const savedTempFlags = tempFlags;
-            tempFlags = 0;
-
-            write(" {");
-            emitList(node, node.members, ListFormat.EnumMembers);
-            write("}");
-            tempFlags = savedTempFlags;
-        }
-
-        function emitModuleDeclaration(node: ModuleDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
-            emit(node.name);
-
-            let body = node.body;
-            while (body.kind === SyntaxKind.ModuleDeclaration) {
-                write(".");
-                emit((<ModuleDeclaration>body).name);
-                body = (<ModuleDeclaration>body).body;
-            }
-
-            write(" ");
-            emit(body);
-        }
-
-        function emitModuleBlock(node: ModuleBlock) {
-            if (isEmptyBlock(node)) {
-                write("{ }");
-            }
-            else {
-                const savedTempFlags = tempFlags;
-                tempFlags = 0;
-                write("{");
-                increaseIndent();
-                emitBlockStatements(node);
-                write("}");
-                tempFlags = savedTempFlags;
-            }
-        }
-
-        function emitCaseBlock(node: CaseBlock) {
-            writeToken(SyntaxKind.OpenBraceToken, node.pos);
-            emitList(node, node.clauses, ListFormat.CaseBlockClauses);
-            writeToken(SyntaxKind.CloseBraceToken, node.clauses.end);
-        }
-
-        function emitImportEqualsDeclaration(node: ImportEqualsDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("import ");
-            emit(node.name);
-            write(" = ");
-            emitModuleReference(node.moduleReference);
-            write(";");
-        }
-
-        function emitModuleReference(node: ModuleReference) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        function emitImportDeclaration(node: ImportDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("import ");
-            if (node.importClause) {
-                emit(node.importClause);
-                write(" from ");
-            }
-            emitExpression(node.moduleSpecifier);
-            write(";");
-        }
-
-        function emitImportClause(node: ImportClause) {
-            emit(node.name);
-            if (node.name && node.namedBindings) {
-                write(", ");
-            }
-            emit(node.namedBindings);
-        }
-
-        function emitNamespaceImport(node: NamespaceImport) {
-            write("* as ");
-            emit(node.name);
-        }
-
-        function emitNamedImports(node: NamedImports) {
-            emitNamedImportsOrExports(node);
-        }
-
-        function emitImportSpecifier(node: ImportSpecifier) {
-            emitImportOrExportSpecifier(node);
-        }
-
-        function emitExportAssignment(node: ExportAssignment) {
-            write(node.isExportEquals ? "export = " : "export default ");
-            emitExpression(node.expression);
-            write(";");
-        }
-
-        function emitExportDeclaration(node: ExportDeclaration) {
-            write("export ");
-            if (node.exportClause) {
-                emit(node.exportClause);
-            }
-            else {
-                write("*");
-            }
-            if (node.moduleSpecifier) {
-                write(" from ");
-                emitExpression(node.moduleSpecifier);
-            }
-            write(";");
-        }
-
-        function emitNamedExports(node: NamedExports) {
-            emitNamedImportsOrExports(node);
-        }
-
-        function emitExportSpecifier(node: ExportSpecifier) {
-            emitImportOrExportSpecifier(node);
-        }
-
-        function emitNamedImportsOrExports(node: NamedImportsOrExports) {
-            write("{");
-            emitList(node, node.elements, ListFormat.NamedImportsOrExportsElements);
-            write("}");
-        }
-
-        function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
-            if (node.propertyName) {
-                emit(node.propertyName);
-                write(" as ");
-            }
-
-            emit(node.name);
-        }
-
-        //
-        // Module references
-        //
-
-        function emitExternalModuleReference(node: ExternalModuleReference) {
-            write("require(");
-            emitExpression(node.expression);
-            write(")");
-        }
-
-        //
-        // JSX
-        //
-
-        function emitJsxElement(node: JsxElement) {
-            emit(node.openingElement);
-            emitList(node, node.children, ListFormat.JsxElementChildren);
-            emit(node.closingElement);
-        }
-
-        function emitJsxSelfClosingElement(node: JsxSelfClosingElement) {
-            write("<");
-            emitJsxTagName(node.tagName);
-            write(" ");
-            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
-            write("/>");
-        }
-
-        function emitJsxOpeningElement(node: JsxOpeningElement) {
-            write("<");
-            emitJsxTagName(node.tagName);
-            writeIfAny(node.attributes, " ");
-            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
-            write(">");
-        }
-
-        function emitJsxText(node: JsxText) {
-            writer.writeLiteral(getTextOfNode(node, /*includeTrivia*/ true));
-        }
-
-        function emitJsxClosingElement(node: JsxClosingElement) {
-            write("</");
-            emitJsxTagName(node.tagName);
-            write(">");
-        }
-
-        function emitJsxAttribute(node: JsxAttribute) {
-            emit(node.name);
-            emitWithPrefix("=", node.initializer);
-        }
-
-        function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {
-            write("{...");
-            emitExpression(node.expression);
-            write("}");
-        }
-
-        function emitJsxExpression(node: JsxExpression) {
-            if (node.expression) {
-                write("{");
-                if (node.dotDotDotToken) {
-                    write("...");
-                }
-                emitExpression(node.expression);
-                write("}");
-            }
-        }
-
-        function emitJsxTagName(node: JsxTagNameExpression) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        //
-        // Clauses
-        //
-
-        function emitCaseClause(node: CaseClause) {
-            write("case ");
-            emitExpression(node.expression);
-            write(":");
-
-            emitCaseOrDefaultClauseStatements(node, node.statements);
-        }
-
-        function emitDefaultClause(node: DefaultClause) {
-            write("default:");
-            emitCaseOrDefaultClauseStatements(node, node.statements);
-        }
-
-        function emitCaseOrDefaultClauseStatements(parentNode: Node, statements: NodeArray<Statement>) {
-            const emitAsSingleStatement =
-                statements.length === 1 &&
-                (
-                    // treat synthesized nodes as located on the same line for emit purposes
-                    nodeIsSynthesized(parentNode) ||
-                    nodeIsSynthesized(statements[0]) ||
-                    rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)
-                );
-
-            if (emitAsSingleStatement) {
-                write(" ");
-                emit(statements[0]);
-            }
-            else {
-                emitList(parentNode, statements, ListFormat.CaseOrDefaultClauseStatements);
-            }
-        }
-
-        function emitHeritageClause(node: HeritageClause) {
-            write(" ");
-            writeTokenText(node.token);
-            write(" ");
-            emitList(node, node.types, ListFormat.HeritageClauseTypes);
-        }
-
-        function emitCatchClause(node: CatchClause) {
-            writeLine();
-            const openParenPos = writeToken(SyntaxKind.CatchKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emit(node.variableDeclaration);
-            writeToken(SyntaxKind.CloseParenToken, node.variableDeclaration ? node.variableDeclaration.end : openParenPos);
-            write(" ");
-            emit(node.block);
-        }
-
-        //
-        // Property assignments
-        //
-
-        function emitPropertyAssignment(node: PropertyAssignment) {
-            emit(node.name);
-            write(": ");
-            // This is to ensure that we emit comment in the following case:
-            //      For example:
-            //          obj = {
-            //              id: /*comment1*/ ()=>void
-            //          }
-            // "comment1" is not considered to be leading comment for node.initializer
-            // but rather a trailing comment on the previous node.
-            const initializer = node.initializer;
-            if ((getEmitFlags(initializer) & EmitFlags.NoLeadingComments) === 0) {
-                const commentRange = getCommentRange(initializer);
-                emitTrailingCommentsOfPosition(commentRange.pos);
-            }
-
-            emitExpression(initializer);
-        }
-
-        function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {
-            emit(node.name);
-            if (node.objectAssignmentInitializer) {
-                write(" = ");
-                emitExpression(node.objectAssignmentInitializer);
-            }
-        }
-
-        function emitSpreadAssignment(node: SpreadAssignment) {
-            if (node.expression) {
-                write("...");
-                emitExpression(node.expression);
-            }
-        }
-
-        //
-        // Enum
-        //
-
-        function emitEnumMember(node: EnumMember) {
-            emit(node.name);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        //
-        // Top-level nodes
-        //
-
-        function emitSourceFile(node: SourceFile) {
-            writeLine();
-            emitShebang();
-            emitBodyWithDetachedComments(node, node.statements, emitSourceFileWorker);
-        }
-
-        function emitSourceFileWorker(node: SourceFile) {
-            const statements = node.statements;
-            const statementOffset = emitPrologueDirectives(statements);
-            const savedTempFlags = tempFlags;
-            tempFlags = 0;
-            emitHelpers(node);
-            emitList(node, statements, ListFormat.MultiLine, statementOffset);
-            tempFlags = savedTempFlags;
-        }
-
-        // Transformation nodes
-
-        function emitPartiallyEmittedExpression(node: PartiallyEmittedExpression) {
-            emitExpression(node.expression);
-        }
-
-        /**
-         * Emits any prologue directives at the start of a Statement list, returning the
-         * number of prologue directives written to the output.
-         */
-        function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean): number {
-            for (let i = 0; i < statements.length; i++) {
-                if (isPrologueDirective(statements[i])) {
-                    if (startWithNewLine || i > 0) {
-                        writeLine();
-                    }
-                    emit(statements[i]);
-                }
-                else {
-                    // return index of the first non prologue directive
-                    return i;
-                }
-            }
-
-            return statements.length;
-        }
-
-        function emitHelpers(node: Node, isBundle?: boolean) {
-            const sourceFile = isSourceFile(node) ? node : currentSourceFile;
-            const shouldSkip = compilerOptions.noEmitHelpers || (sourceFile && getExternalHelpersModuleName(sourceFile) !== undefined);
-            const shouldBundle = isSourceFile(node) && !isOwnFileEmit;
-
+        function emitHelpers(node: Node, writeLines: (text: string) => void) {
             let helpersEmitted = false;
-            const helpers = getEmitHelpers(node);
-            if (helpers) {
-                for (const helper of stableSort(helpers, compareEmitHelpers)) {
-                    if (!helper.scoped) {
-                        // Skip the helper if it can be skipped and the noEmitHelpers compiler
-                        // option is set, or if it can be imported and the importHelpers compiler
-                        // option is set.
-                        if (shouldSkip) continue;
+            const bundle = node.kind === SyntaxKind.Bundle ? <Bundle>node : undefined;
+            const numNodes = bundle ? bundle.sourceFiles.length : 1;
+            for (let i = 0; i < numNodes; i++) {
+                const currentNode = bundle ? bundle.sourceFiles[i] : node;
+                const sourceFile = isSourceFile(currentNode) ? currentNode : currentSourceFile;
+                const shouldSkip = compilerOptions.noEmitHelpers || (sourceFile && getExternalHelpersModuleName(sourceFile) !== undefined);
+                const shouldBundle = isSourceFile(currentNode) && !isOwnFileEmit;
+                const helpers = getEmitHelpers(currentNode);
+                if (helpers) {
+                    for (const helper of stableSort(helpers, compareEmitHelpers)) {
+                        if (!helper.scoped) {
+                            // Skip the helper if it can be skipped and the noEmitHelpers compiler
+                            // option is set, or if it can be imported and the importHelpers compiler
+                            // option is set.
+                            if (shouldSkip) continue;
 
-                        // Skip the helper if it can be bundled but hasn't already been emitted and we
-                        // are emitting a bundled module.
-                        if (shouldBundle) {
-                            if (bundledHelpers.get(helper.name)) {
-                                continue;
+                            // Skip the helper if it can be bundled but hasn't already been emitted and we
+                            // are emitting a bundled module.
+                            if (shouldBundle) {
+                                if (bundledHelpers.get(helper.name)) {
+                                    continue;
+                                }
+
+                                bundledHelpers.set(helper.name, true);
                             }
-
-                            bundledHelpers.set(helper.name, true);
                         }
-                    }
-                    else if (isBundle) {
-                        // Skip the helper if it is scoped and we are emitting bundled helpers
-                        continue;
-                    }
+                        else if (bundle) {
+                            // Skip the helper if it is scoped and we are emitting bundled helpers
+                            continue;
+                        }
 
-                    writeLines(helper.text);
-                    helpersEmitted = true;
+                        writeLines(helper.text);
+                        helpersEmitted = true;
+                    }
                 }
             }
 
-            if (helpersEmitted) {
-                writeLine();
-            }
-
             return helpersEmitted;
         }
-
-        function writeLines(text: string): void {
-            const lines = text.split(/\r\n?|\n/g);
-            const indentation = guessIndentation(lines);
-            for (let i = 0; i < lines.length; i++) {
-                const line = indentation ? lines[i].slice(indentation) : lines[i];
-                if (line.length) {
-                    if (i > 0) {
-                        writeLine();
-                    }
-                    write(line);
-                }
-            }
-        }
-
-        function guessIndentation(lines: string[]) {
-            let indentation: number;
-            for (const line of lines) {
-                for (let i = 0; i < line.length && (indentation === undefined || i < indentation); i++) {
-                    if (!isWhiteSpace(line.charCodeAt(i))) {
-                        if (indentation === undefined || i < indentation) {
-                            indentation = i;
-                            break;
-                        }
-                    }
-                }
-            }
-            return indentation;
-        }
-
-        //
-        // Helpers
-        //
-
-        function emitShebang() {
-            const shebang = getShebang(currentText);
-            if (shebang) {
-                write(shebang);
-                writeLine();
-            }
-        }
-
-        function emitModifiers(node: Node, modifiers: NodeArray<Modifier>) {
-            if (modifiers && modifiers.length) {
-                emitList(node, modifiers, ListFormat.Modifiers);
-                write(" ");
-            }
-        }
-
-        function emitWithPrefix(prefix: string, node: Node) {
-            emitNodeWithPrefix(prefix, node, emit);
-        }
-
-        function emitExpressionWithPrefix(prefix: string, node: Node) {
-            emitNodeWithPrefix(prefix, node, emitExpression);
-        }
-
-        function emitNodeWithPrefix(prefix: string, node: Node, emit: (node: Node) => void) {
-            if (node) {
-                write(prefix);
-                emit(node);
-            }
-        }
-
-        function emitWithSuffix(node: Node, suffix: string) {
-            if (node) {
-                emit(node);
-                write(suffix);
-            }
-        }
-
-        function emitEmbeddedStatement(parent: Node, node: Statement) {
-            if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
-                write(" ");
-                emit(node);
-            }
-            else {
-                writeLine();
-                increaseIndent();
-                emit(node);
-                decreaseIndent();
-            }
-        }
-
-        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator>) {
-            emitList(parentNode, decorators, ListFormat.Decorators);
-        }
-
-        function emitTypeArguments(parentNode: Node, typeArguments: NodeArray<TypeNode>) {
-            emitList(parentNode, typeArguments, ListFormat.TypeArguments);
-        }
-
-        function emitTypeParameters(parentNode: Node, typeParameters: NodeArray<TypeParameterDeclaration>) {
-            emitList(parentNode, typeParameters, ListFormat.TypeParameters);
-        }
-
-        function emitParameters(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            emitList(parentNode, parameters, ListFormat.Parameters);
-        }
-
-        function emitParametersForArrow(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            if (parameters &&
-                parameters.length === 1 &&
-                parameters[0].type === undefined &&
-                parameters[0].pos === parentNode.pos) {
-                emit(parameters[0]);
-            }
-            else {
-                emitParameters(parentNode, parameters);
-            }
-        }
-
-        function emitParametersForIndexSignature(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            emitList(parentNode, parameters, ListFormat.IndexSignatureParameters);
-        }
-
-        function emitList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
-            emitNodeList(emit, parentNode, children, format, start, count);
-        }
-
-        function emitExpressionList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
-            emitNodeList(emitExpression, parentNode, children, format, start, count);
-        }
-
-        function emitNodeList(emit: (node: Node) => void, parentNode: Node, children: NodeArray<Node>, format: ListFormat, start = 0, count = children ? children.length - start : 0) {
-            const isUndefined = children === undefined;
-            if (isUndefined && format & ListFormat.OptionalIfUndefined) {
-                return;
-            }
-
-            const isEmpty = isUndefined || children.length === 0 || start >= children.length || count === 0;
-            if (isEmpty && format & ListFormat.OptionalIfEmpty) {
-                return;
-            }
-
-            if (format & ListFormat.BracketsMask) {
-                write(getOpeningBracket(format));
-            }
-
-            if (isEmpty) {
-                // Write a line terminator if the parent node was multi-line
-                if (format & ListFormat.MultiLine) {
-                    writeLine();
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-            }
-            else {
-                // Write the opening line terminator or leading whitespace.
-                const mayEmitInterveningComments = (format & ListFormat.NoInterveningComments) === 0;
-                let shouldEmitInterveningComments = mayEmitInterveningComments;
-                if (shouldWriteLeadingLineTerminator(parentNode, children, format)) {
-                    writeLine();
-                    shouldEmitInterveningComments = false;
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-
-                // Increase the indent, if requested.
-                if (format & ListFormat.Indented) {
-                    increaseIndent();
-                }
-
-                // Emit each child.
-                let previousSibling: Node;
-                let shouldDecreaseIndentAfterEmit: boolean;
-                const delimiter = getDelimiter(format);
-                for (let i = 0; i < count; i++) {
-                    const child = children[start + i];
-
-                    // Write the delimiter if this is not the first node.
-                    if (previousSibling) {
-                        write(delimiter);
-
-                        // Write either a line terminator or whitespace to separate the elements.
-                        if (shouldWriteSeparatingLineTerminator(previousSibling, child, format)) {
-                            // If a synthesized node in a single-line list starts on a new
-                            // line, we should increase the indent.
-                            if ((format & (ListFormat.LinesMask | ListFormat.Indented)) === ListFormat.SingleLine) {
-                                increaseIndent();
-                                shouldDecreaseIndentAfterEmit = true;
-                            }
-
-                            writeLine();
-                            shouldEmitInterveningComments = false;
-                        }
-                        else if (previousSibling && format & ListFormat.SpaceBetweenSiblings) {
-                            write(" ");
-                        }
-                    }
-
-                    if (shouldEmitInterveningComments) {
-                        const commentRange = getCommentRange(child);
-                        emitTrailingCommentsOfPosition(commentRange.pos);
-                    }
-                    else {
-                        shouldEmitInterveningComments = mayEmitInterveningComments;
-                    }
-
-                    // Emit this child.
-                    emit(child);
-
-                    if (shouldDecreaseIndentAfterEmit) {
-                        decreaseIndent();
-                        shouldDecreaseIndentAfterEmit = false;
-                    }
-
-                    previousSibling = child;
-                }
-
-                // Write a trailing comma, if requested.
-                const hasTrailingComma = (format & ListFormat.AllowTrailingComma) && children.hasTrailingComma;
-                if (format & ListFormat.CommaDelimited && hasTrailingComma) {
-                    write(",");
-                }
-
-                // Decrease the indent, if requested.
-                if (format & ListFormat.Indented) {
-                    decreaseIndent();
-                }
-
-                // Write the closing line terminator or closing whitespace.
-                if (shouldWriteClosingLineTerminator(parentNode, children, format)) {
-                    writeLine();
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-            }
-
-            if (format & ListFormat.BracketsMask) {
-                write(getClosingBracket(format));
-            }
-        }
-
-        function writeLineOrSpace(node: Node) {
-            if (getEmitFlags(node) & EmitFlags.SingleLine) {
-                write(" ");
-            }
-            else {
-                writeLine();
-            }
-        }
-
-        function writeIfAny(nodes: NodeArray<Node>, text: string) {
-            if (nodes && nodes.length > 0) {
-                write(text);
-            }
-        }
-
-        function writeIfPresent(node: Node, text: string) {
-            if (node !== undefined) {
-                write(text);
-            }
-        }
-
-        function writeToken(token: SyntaxKind, pos: number, contextNode?: Node) {
-            return emitTokenWithSourceMap(contextNode, token, pos, writeTokenText);
-        }
-
-        function writeTokenText(token: SyntaxKind, pos?: number) {
-            const tokenString = tokenToString(token);
-            write(tokenString);
-            return pos < 0 ? pos : pos + tokenString.length;
-        }
-
-        function increaseIndentIf(value: boolean, valueToWriteWhenNotIndenting?: string) {
-            if (value) {
-                increaseIndent();
-                writeLine();
-            }
-            else if (valueToWriteWhenNotIndenting) {
-                write(valueToWriteWhenNotIndenting);
-            }
-        }
-
-        // Helper function to decrease the indent if we previously indented.  Allows multiple
-        // previous indent values to be considered at a time.  This also allows caller to just
-        // call this once, passing in all their appropriate indent values, instead of needing
-        // to call this helper function multiple times.
-        function decreaseIndentIf(value1: boolean, value2?: boolean) {
-            if (value1) {
-                decreaseIndent();
-            }
-            if (value2) {
-                decreaseIndent();
-            }
-        }
-
-        function shouldWriteLeadingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return true;
-            }
-
-            if (format & ListFormat.PreserveLines) {
-                if (format & ListFormat.PreferNewLine) {
-                    return true;
-                }
-
-                const firstChild = children[0];
-                if (firstChild === undefined) {
-                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
-                }
-                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(firstChild)) {
-                    return synthesizedNodeStartsOnNewLine(firstChild, format);
-                }
-                else {
-                    return !rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile);
-                }
-            }
-            else {
-                return false;
-            }
-        }
-
-        function shouldWriteSeparatingLineTerminator(previousNode: Node, nextNode: Node, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return true;
-            }
-            else if (format & ListFormat.PreserveLines) {
-                if (previousNode === undefined || nextNode === undefined) {
-                    return false;
-                }
-                else if (nodeIsSynthesized(previousNode) || nodeIsSynthesized(nextNode)) {
-                    return synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format);
-                }
-                else {
-                    return !rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile);
-                }
-            }
-            else {
-                return nextNode.startsOnNewLine;
-            }
-        }
-
-        function shouldWriteClosingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return (format & ListFormat.NoTrailingNewLine) === 0;
-            }
-            else if (format & ListFormat.PreserveLines) {
-                if (format & ListFormat.PreferNewLine) {
-                    return true;
-                }
-
-                const lastChild = lastOrUndefined(children);
-                if (lastChild === undefined) {
-                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
-                }
-                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(lastChild)) {
-                    return synthesizedNodeStartsOnNewLine(lastChild, format);
-                }
-                else {
-                    return !rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile);
-                }
-            }
-            else {
-                return false;
-            }
-        }
-
-        function synthesizedNodeStartsOnNewLine(node: Node, format?: ListFormat) {
-            if (nodeIsSynthesized(node)) {
-                const startsOnNewLine = node.startsOnNewLine;
-                if (startsOnNewLine === undefined) {
-                    return (format & ListFormat.PreferNewLine) !== 0;
-                }
-
-                return startsOnNewLine;
-            }
-
-            return (format & ListFormat.PreferNewLine) !== 0;
-        }
-
-        function needsIndentation(parent: Node, node1: Node, node2: Node): boolean {
-            parent = skipSynthesizedParentheses(parent);
-            node1 = skipSynthesizedParentheses(node1);
-            node2 = skipSynthesizedParentheses(node2);
-
-            // Always use a newline for synthesized code if the synthesizer desires it.
-            if (node2.startsOnNewLine) {
-                return true;
-            }
-
-            return !nodeIsSynthesized(parent)
-                && !nodeIsSynthesized(node1)
-                && !nodeIsSynthesized(node2)
-                && !rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile);
-        }
-
-        function skipSynthesizedParentheses(node: Node) {
-            while (node.kind === SyntaxKind.ParenthesizedExpression && nodeIsSynthesized(node)) {
-                node = (<ParenthesizedExpression>node).expression;
-            }
-
-            return node;
-        }
-
-        function getTextOfNode(node: Node, includeTrivia?: boolean): string {
-            if (isGeneratedIdentifier(node)) {
-                return getGeneratedIdentifier(<Identifier>node);
-            }
-            else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
-                return unescapeIdentifier(node.text);
-            }
-            else if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
-                return getTextOfNode((<StringLiteral>node).textSourceNode, includeTrivia);
-            }
-            else if (isLiteralExpression(node) && (nodeIsSynthesized(node) || !node.parent)) {
-                return node.text;
-            }
-
-            return getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia);
-        }
-
-        function getLiteralTextOfNode(node: LiteralLikeNode): string {
-            if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
-                const textSourceNode = (<StringLiteral>node).textSourceNode;
-                if (isIdentifier(textSourceNode)) {
-                    return "\"" + escapeNonAsciiCharacters(escapeString(getTextOfNode(textSourceNode))) + "\"";
-                }
-                else {
-                    return getLiteralTextOfNode(textSourceNode);
-                }
-            }
-
-            return getLiteralText(node, currentSourceFile, languageVersion);
-        }
-
-        function isSingleLineEmptyBlock(block: Block) {
-            return !block.multiLine
-                && isEmptyBlock(block);
-        }
-
-        function isEmptyBlock(block: BlockLike) {
-            return block.statements.length === 0
-                && rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
-        }
-
-        function isUniqueName(name: string): boolean {
-            return !resolver.hasGlobalName(name) &&
-                !currentFileIdentifiers.has(name) &&
-                !generatedNameSet.has(name);
-        }
-
-        function isUniqueLocalName(name: string, container: Node): boolean {
-            for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
-                if (node.locals) {
-                    const local = node.locals.get(name);
-                    // We conservatively include alias symbols to cover cases where they're emitted as locals
-                    if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-
-        /**
-        * Return the next available name in the pattern _a ... _z, _0, _1, ...
-        * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.
-        * Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
-        */
-        function makeTempVariableName(flags: TempFlags): string {
-            if (flags && !(tempFlags & flags)) {
-                const name = flags === TempFlags._i ? "_i" : "_n";
-                if (isUniqueName(name)) {
-                    tempFlags |= flags;
-                    return name;
-                }
-            }
-            while (true) {
-                const count = tempFlags & TempFlags.CountMask;
-                tempFlags++;
-                // Skip over 'i' and 'n'
-                if (count !== 8 && count !== 13) {
-                    const name = count < 26
-                        ? "_" + String.fromCharCode(CharacterCodes.a + count)
-                        : "_" + (count - 26);
-                    if (isUniqueName(name)) {
-                        return name;
-                    }
-                }
-            }
-        }
-
-        // Generate a name that is unique within the current file and doesn't conflict with any names
-        // in global scope. The name is formed by adding an '_n' suffix to the specified base name,
-        // where n is a positive integer. Note that names generated by makeTempVariableName and
-        // makeUniqueName are guaranteed to never conflict.
-        function makeUniqueName(baseName: string): string {
-            // Find the first unique 'name_n', where n is a positive number
-            if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {
-                baseName += "_";
-            }
-            let i = 1;
-            while (true) {
-                const generatedName = baseName + i;
-                if (isUniqueName(generatedName)) {
-                    generatedNameSet.set(generatedName, generatedName);
-                    return generatedName;
-                }
-                i++;
-            }
-        }
-
-        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {
-            const name = getTextOfNode(node.name);
-            // Use module/enum name itself if it is unique, otherwise make a unique variation
-            return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
-        }
-
-        function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {
-            const expr = getExternalModuleName(node);
-            const baseName = expr.kind === SyntaxKind.StringLiteral ?
-                escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";
-            return makeUniqueName(baseName);
-        }
-
-        function generateNameForExportDefault() {
-            return makeUniqueName("default");
-        }
-
-        function generateNameForClassExpression() {
-            return makeUniqueName("class");
-        }
-
-        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration) {
-            if (isIdentifier(node.name)) {
-                return generateNameForNodeCached(node.name);
-            }
-            return makeTempVariableName(TempFlags.Auto);
-        }
-
-        /**
-         * Generates a unique name from a node.
-         *
-         * @param node A node.
-         */
-        function generateNameForNode(node: Node): string {
-            switch (node.kind) {
-                case SyntaxKind.Identifier:
-                    return makeUniqueName(getTextOfNode(node));
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node);
-                case SyntaxKind.ImportDeclaration:
-                case SyntaxKind.ExportDeclaration:
-                    return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.ExportAssignment:
-                    return generateNameForExportDefault();
-                case SyntaxKind.ClassExpression:
-                    return generateNameForClassExpression();
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node);
-                default:
-                    return makeTempVariableName(TempFlags.Auto);
-            }
-        }
-
-        /**
-         * Generates a unique identifier for a node.
-         *
-         * @param name A generated name.
-         */
-        function generateName(name: Identifier) {
-            switch (name.autoGenerateKind) {
-                case GeneratedIdentifierKind.Auto:
-                    return makeTempVariableName(TempFlags.Auto);
-                case GeneratedIdentifierKind.Loop:
-                    return makeTempVariableName(TempFlags._i);
-                case GeneratedIdentifierKind.Unique:
-                    return makeUniqueName(name.text);
-            }
-
-            Debug.fail("Unsupported GeneratedIdentifierKind.");
-        }
-
-        /**
-         * Gets the node from which a name should be generated.
-         *
-         * @param name A generated name wrapper.
-         */
-        function getNodeForGeneratedName(name: Identifier) {
-            const autoGenerateId = name.autoGenerateId;
-            let node = name as Node;
-            let original = node.original;
-            while (original) {
-                node = original;
-
-                // if "node" is a different generated name (having a different
-                // "autoGenerateId"), use it and stop traversing.
-                if (isIdentifier(node)
-                    && node.autoGenerateKind === GeneratedIdentifierKind.Node
-                    && node.autoGenerateId !== autoGenerateId) {
-                    break;
-                }
-
-                original = node.original;
-            }
-
-            // otherwise, return the original node for the source;
-            return node;
-        }
-
-        function generateNameForNodeCached(node: Node) {
-            const nodeId = getNodeId(node);
-            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node)));
-        }
-
-        /**
-         * Gets the generated identifier text from a generated identifier.
-         *
-         * @param name The generated identifier.
-         */
-        function getGeneratedIdentifier(name: Identifier) {
-            if (name.autoGenerateKind === GeneratedIdentifierKind.Node) {
-                // Generated names generate unique names based on their original node
-                // and are cached based on that node's id
-                const node = getNodeForGeneratedName(name);
-                return generateNameForNodeCached(node);
-            }
-            else {
-                // Auto, Loop, and Unique names are cached based on their unique
-                // autoGenerateId.
-                const autoGenerateId = name.autoGenerateId;
-                return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = unescapeIdentifier(generateName(name)));
-            }
-        }
-
-        function createDelimiterMap() {
-            const delimiters: string[] = [];
-            delimiters[ListFormat.None] = "";
-            delimiters[ListFormat.CommaDelimited] = ",";
-            delimiters[ListFormat.BarDelimited] = " |";
-            delimiters[ListFormat.AmpersandDelimited] = " &";
-            return delimiters;
-        }
-
-        function getDelimiter(format: ListFormat) {
-            return delimiters[format & ListFormat.DelimitersMask];
-        }
-
-        function createBracketsMap() {
-            const brackets: string[][] = [];
-            brackets[ListFormat.Braces] = ["{", "}"];
-            brackets[ListFormat.Parenthesis] = ["(", ")"];
-            brackets[ListFormat.AngleBrackets] = ["<", ">"];
-            brackets[ListFormat.SquareBrackets] = ["[", "]"];
-            return brackets;
-        }
-
-        function getOpeningBracket(format: ListFormat) {
-            return brackets[format & ListFormat.BracketsMask][0];
-        }
-
-        function getClosingBracket(format: ListFormat) {
-            return brackets[format & ListFormat.BracketsMask][1];
-        }
     }
-
-    const enum ListFormat {
-        None = 0,
-
-        // Line separators
-        SingleLine = 0,                 // Prints the list on a single line (default).
-        MultiLine = 1 << 0,             // Prints the list on multiple lines.
-        PreserveLines = 1 << 1,         // Prints the list using line preservation if possible.
-        LinesMask = SingleLine | MultiLine | PreserveLines,
-
-        // Delimiters
-        NotDelimited = 0,               // There is no delimiter between list items (default).
-        BarDelimited = 1 << 2,          // Each list item is space-and-bar (" |") delimited.
-        AmpersandDelimited = 1 << 3,    // Each list item is space-and-ampersand (" &") delimited.
-        CommaDelimited = 1 << 4,        // Each list item is comma (",") delimited.
-        DelimitersMask = BarDelimited | AmpersandDelimited | CommaDelimited,
-
-        AllowTrailingComma = 1 << 5,    // Write a trailing comma (",") if present.
-
-        // Whitespace
-        Indented = 1 << 6,              // The list should be indented.
-        SpaceBetweenBraces = 1 << 7,    // Inserts a space after the opening brace and before the closing brace.
-        SpaceBetweenSiblings = 1 << 8,  // Inserts a space between each sibling node.
-
-        // Brackets/Braces
-        Braces = 1 << 9,                 // The list is surrounded by "{" and "}".
-        Parenthesis = 1 << 10,          // The list is surrounded by "(" and ")".
-        AngleBrackets = 1 << 11,        // The list is surrounded by "<" and ">".
-        SquareBrackets = 1 << 12,       // The list is surrounded by "[" and "]".
-        BracketsMask = Braces | Parenthesis | AngleBrackets | SquareBrackets,
-
-        OptionalIfUndefined = 1 << 13,  // Do not emit brackets if the list is undefined.
-        OptionalIfEmpty = 1 << 14,      // Do not emit brackets if the list is empty.
-        Optional = OptionalIfUndefined | OptionalIfEmpty,
-
-        // Other
-        PreferNewLine = 1 << 15,        // Prefer adding a LineTerminator between synthesized nodes.
-        NoTrailingNewLine = 1 << 16,    // Do not emit a trailing NewLine for a MultiLine list.
-        NoInterveningComments = 1 << 17, // Do not emit comments between each node
-
-        // Precomputed Formats
-        Modifiers = SingleLine | SpaceBetweenSiblings,
-        HeritageClauses = SingleLine | SpaceBetweenSiblings,
-        TypeLiteralMembers = MultiLine | Indented,
-        TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented,
-        UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine,
-        IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine,
-        ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings,
-        ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings,
-        ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces,
-        ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
-        CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
-        NewExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis | OptionalIfUndefined,
-        TemplateExpressionSpans = SingleLine | NoInterveningComments,
-        SingleLineBlockStatements = SpaceBetweenBraces | SpaceBetweenSiblings | SingleLine,
-        MultiLineBlockStatements = Indented | MultiLine,
-        VariableDeclarationList = CommaDelimited | SpaceBetweenSiblings | SingleLine,
-        SingleLineFunctionBodyStatements = SingleLine | SpaceBetweenSiblings | SpaceBetweenBraces,
-        MultiLineFunctionBodyStatements = MultiLine,
-        ClassHeritageClauses = SingleLine | SpaceBetweenSiblings,
-        ClassMembers = Indented | MultiLine,
-        InterfaceMembers = Indented | MultiLine,
-        EnumMembers = CommaDelimited | Indented | MultiLine,
-        CaseBlockClauses = Indented | MultiLine,
-        NamedImportsOrExportsElements = CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | SingleLine | SpaceBetweenBraces,
-        JsxElementChildren = SingleLine | NoInterveningComments,
-        JsxElementAttributes = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
-        CaseOrDefaultClauseStatements = Indented | MultiLine | NoTrailingNewLine | OptionalIfEmpty,
-        HeritageClauseTypes = CommaDelimited | SpaceBetweenSiblings | SingleLine,
-        SourceFileStatements = MultiLine | NoTrailingNewLine,
-        Decorators = MultiLine | Optional,
-        TypeArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
-        TypeParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
-        Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis,
-        IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
-    }
-}
+}
\ No newline at end of file
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index f63094ae16d..f2a8de3a93b 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -1530,6 +1530,19 @@ namespace ts {
         return node;
     }
 
+    export function createBundle(sourceFiles: SourceFile[]) {
+        const node = <Bundle>createNode(SyntaxKind.Bundle);
+        node.sourceFiles = sourceFiles;
+        return node;
+    }
+
+    export function updateBundle(node: Bundle, sourceFiles: SourceFile[]) {
+        if (node.sourceFiles !== sourceFiles) {
+            return createBundle(sourceFiles);
+        }
+        return node;
+    }
+
     // Compound nodes
 
     export function createComma(left: Expression, right: Expression) {
diff --git a/src/compiler/printer.ts b/src/compiler/printer.ts
new file mode 100644
index 00000000000..9ae824dac67
--- /dev/null
+++ b/src/compiler/printer.ts
@@ -0,0 +1,2659 @@
+/// <reference path="checker.ts"/>
+
+namespace ts {
+    // Flags enum to track count of temp variables and a few dedicated names
+    const enum TempFlags {
+        Auto      = 0x00000000,  // No preferred name
+        CountMask = 0x0FFFFFFF,  // Temp variable counter
+        _i        = 0x10000000,  // Use/preference flag for '_i'
+    }
+
+    const delimiters = createDelimiterMap();
+    const brackets = createBracketsMap();
+
+    export function createPrinter(writer: EmitTextWriter, compilerOptions: CompilerOptions, printerOptions: PrinterOptions = {}): Printer {
+        const languageVersion = getEmitScriptTarget(compilerOptions);
+        const moduleKind = getEmitModuleKind(compilerOptions);
+        const {
+            hasGlobalName,
+            onEmitSourceMapOfNode,
+            onEmitSourceMapOfToken,
+            onEmitCommentsOfNode,
+            onEmitDetachedCommentsOfNode,
+            onEmitTrailingCommentsOfPosition,
+            onEmitNode,
+            onEmitHelpers,
+            onSetSourceFile,
+            onSubstituteNode,
+        } = printerOptions;
+        const {
+            write,
+            writeLine,
+            increaseIndent,
+            decreaseIndent
+        } = writer;
+
+        let currentSourceFile: SourceFile;
+        let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
+        let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
+        let generatedNames: Map<string>; // Set of names generated by the NameGenerator.
+        let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
+        let tempFlags: TempFlags; // TempFlags for the current name generation scope.
+
+        return {
+            printNode,
+            printFile,
+            printBundle
+        };
+
+        function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile) {
+            print(hint, node, sourceFile);
+            resetGeneratedNames();
+        }
+
+        function printBundle(bundle: Bundle) {
+            if (moduleKind) {
+                emitHelpersIndirect(bundle);
+            }
+            for (const sourceFile of bundle.sourceFiles) {
+                print(EmitHint.SourceFile, sourceFile, sourceFile);
+            }
+            resetGeneratedNames();
+        }
+
+        function printFile(sourceFile: SourceFile) {
+            print(EmitHint.SourceFile, sourceFile, sourceFile);
+            resetGeneratedNames();
+        }
+
+        function print(hint: EmitHint, node: Node, sourceFile: SourceFile) {
+            setSourceFile(sourceFile);
+            pipelineEmitWithNotification(hint, node);
+        }
+
+        function setSourceFile(sourceFile: SourceFile) {
+            currentSourceFile = sourceFile;
+
+            if (onSetSourceFile) {
+                onSetSourceFile(sourceFile);
+            }
+        }
+
+        function emit(node: Node, hint = EmitHint.Unspecified) {
+            pipelineEmitWithNotification(hint, node);
+        }
+
+        function emitIdentifierName(node: Identifier) {
+            pipelineEmitWithNotification(EmitHint.IdentifierName, node);
+        }
+
+        function emitExpression(node: Expression) {
+            pipelineEmitWithNotification(EmitHint.Expression, node);
+        }
+
+        function pipelineEmitWithNotification(hint: EmitHint, node: Node) {
+            if (onEmitNode) {
+                onEmitNode(hint, node, pipelineEmitWithComments);
+            }
+            else {
+                pipelineEmitWithComments(hint, node);
+            }
+        }
+
+        function pipelineEmitWithComments(hint: EmitHint, node: Node) {
+            if (onEmitCommentsOfNode && hint !== EmitHint.SourceFile) {
+                onEmitCommentsOfNode(hint, node, pipelineEmitWithSourceMap);
+            }
+            else {
+                pipelineEmitWithSourceMap(hint, node);
+            }
+        }
+
+        function pipelineEmitWithSourceMap(hint: EmitHint, node: Node) {
+            if (onEmitSourceMapOfNode && hint !== EmitHint.SourceFile && hint !== EmitHint.IdentifierName) {
+                onEmitSourceMapOfNode(hint, node, pipelineEmitWithSubstitution);
+            }
+            else {
+                pipelineEmitWithSubstitution(hint, node);
+            }
+        }
+
+        function pipelineEmitWithSubstitution(hint: EmitHint, node: Node) {
+            if (onSubstituteNode) {
+                onSubstituteNode(hint, node, pipelineEmitWithHint);
+            }
+            else {
+                pipelineEmitWithHint(hint, node);
+            }
+        }
+
+        function pipelineEmitWithHint(hint: EmitHint, node: Node): void {
+            switch (hint) {
+                case EmitHint.SourceFile: return pipelineEmitSourceFile(node);
+                case EmitHint.IdentifierName: return pipelineEmitIdentifierName(node);
+                case EmitHint.Expression: return pipelineEmitExpression(node);
+                case EmitHint.Unspecified: return pipelineEmitUnspecified(node);
+            }
+        }
+
+        function pipelineEmitSourceFile(node: Node): void {
+            Debug.assertNode(node, isSourceFile);
+            emitSourceFile(<SourceFile>node);
+        }
+
+        function pipelineEmitIdentifierName(node: Node): void {
+            Debug.assertNode(node, isIdentifier);
+            emitIdentifier(<Identifier>node);
+        }
+
+        function pipelineEmitUnspecified(node: Node): void {
+            const kind = node.kind;
+            switch (kind) {
+                // Pseudo-literals
+                case SyntaxKind.TemplateHead:
+                case SyntaxKind.TemplateMiddle:
+                case SyntaxKind.TemplateTail:
+                    return emitLiteral(<LiteralExpression>node);
+
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(<Identifier>node);
+
+                // Reserved words
+                case SyntaxKind.ConstKeyword:
+                case SyntaxKind.DefaultKeyword:
+                case SyntaxKind.ExportKeyword:
+                case SyntaxKind.VoidKeyword:
+
+                // Strict mode reserved words
+                case SyntaxKind.PrivateKeyword:
+                case SyntaxKind.ProtectedKeyword:
+                case SyntaxKind.PublicKeyword:
+                case SyntaxKind.StaticKeyword:
+
+                // Contextual keywords
+                case SyntaxKind.AbstractKeyword:
+                case SyntaxKind.AsKeyword:
+                case SyntaxKind.AnyKeyword:
+                case SyntaxKind.AsyncKeyword:
+                case SyntaxKind.AwaitKeyword:
+                case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.ConstructorKeyword:
+                case SyntaxKind.DeclareKeyword:
+                case SyntaxKind.GetKeyword:
+                case SyntaxKind.IsKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.NeverKeyword:
+                case SyntaxKind.ReadonlyKeyword:
+                case SyntaxKind.RequireKeyword:
+                case SyntaxKind.NumberKeyword:
+                case SyntaxKind.SetKeyword:
+                case SyntaxKind.StringKeyword:
+                case SyntaxKind.SymbolKeyword:
+                case SyntaxKind.TypeKeyword:
+                case SyntaxKind.UndefinedKeyword:
+                case SyntaxKind.FromKeyword:
+                case SyntaxKind.GlobalKeyword:
+                case SyntaxKind.OfKeyword:
+                    writeTokenText(kind);
+                    return;
+
+                // Parse tree nodes
+
+                // Names
+                case SyntaxKind.QualifiedName:
+                    return emitQualifiedName(<QualifiedName>node);
+                case SyntaxKind.ComputedPropertyName:
+                    return emitComputedPropertyName(<ComputedPropertyName>node);
+
+                // Signature elements
+                case SyntaxKind.TypeParameter:
+                    return emitTypeParameter(<TypeParameterDeclaration>node);
+                case SyntaxKind.Parameter:
+                    return emitParameter(<ParameterDeclaration>node);
+                case SyntaxKind.Decorator:
+                    return emitDecorator(<Decorator>node);
+
+                // Type members
+                case SyntaxKind.PropertySignature:
+                    return emitPropertySignature(<PropertySignature>node);
+                case SyntaxKind.PropertyDeclaration:
+                    return emitPropertyDeclaration(<PropertyDeclaration>node);
+                case SyntaxKind.MethodSignature:
+                    return emitMethodSignature(<MethodSignature>node);
+                case SyntaxKind.MethodDeclaration:
+                    return emitMethodDeclaration(<MethodDeclaration>node);
+                case SyntaxKind.Constructor:
+                    return emitConstructor(<ConstructorDeclaration>node);
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return emitAccessorDeclaration(<AccessorDeclaration>node);
+                case SyntaxKind.CallSignature:
+                    return emitCallSignature(<CallSignatureDeclaration>node);
+                case SyntaxKind.ConstructSignature:
+                    return emitConstructSignature(<ConstructSignatureDeclaration>node);
+                case SyntaxKind.IndexSignature:
+                    return emitIndexSignature(<IndexSignatureDeclaration>node);
+
+                // Types
+                case SyntaxKind.TypePredicate:
+                    return emitTypePredicate(<TypePredicateNode>node);
+                case SyntaxKind.TypeReference:
+                    return emitTypeReference(<TypeReferenceNode>node);
+                case SyntaxKind.FunctionType:
+                    return emitFunctionType(<FunctionTypeNode>node);
+                case SyntaxKind.ConstructorType:
+                    return emitConstructorType(<ConstructorTypeNode>node);
+                case SyntaxKind.TypeQuery:
+                    return emitTypeQuery(<TypeQueryNode>node);
+                case SyntaxKind.TypeLiteral:
+                    return emitTypeLiteral(<TypeLiteralNode>node);
+                case SyntaxKind.ArrayType:
+                    return emitArrayType(<ArrayTypeNode>node);
+                case SyntaxKind.TupleType:
+                    return emitTupleType(<TupleTypeNode>node);
+                case SyntaxKind.UnionType:
+                    return emitUnionType(<UnionTypeNode>node);
+                case SyntaxKind.IntersectionType:
+                    return emitIntersectionType(<IntersectionTypeNode>node);
+                case SyntaxKind.ParenthesizedType:
+                    return emitParenthesizedType(<ParenthesizedTypeNode>node);
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
+                case SyntaxKind.ThisType:
+                    return emitThisType();
+                case SyntaxKind.TypeOperator:
+                    return emitTypeOperator(<TypeOperatorNode>node);
+                case SyntaxKind.IndexedAccessType:
+                    return emitIndexedAccessType(<IndexedAccessTypeNode>node);
+                case SyntaxKind.MappedType:
+                    return emitMappedType(<MappedTypeNode>node);
+                case SyntaxKind.LiteralType:
+                    return emitLiteralType(<LiteralTypeNode>node);
+
+                // Binding patterns
+                case SyntaxKind.ObjectBindingPattern:
+                    return emitObjectBindingPattern(<ObjectBindingPattern>node);
+                case SyntaxKind.ArrayBindingPattern:
+                    return emitArrayBindingPattern(<ArrayBindingPattern>node);
+                case SyntaxKind.BindingElement:
+                    return emitBindingElement(<BindingElement>node);
+
+                // Misc
+                case SyntaxKind.TemplateSpan:
+                    return emitTemplateSpan(<TemplateSpan>node);
+                case SyntaxKind.SemicolonClassElement:
+                    return emitSemicolonClassElement();
+
+                // Statements
+                case SyntaxKind.Block:
+                    return emitBlock(<Block>node);
+                case SyntaxKind.VariableStatement:
+                    return emitVariableStatement(<VariableStatement>node);
+                case SyntaxKind.EmptyStatement:
+                    return emitEmptyStatement();
+                case SyntaxKind.ExpressionStatement:
+                    return emitExpressionStatement(<ExpressionStatement>node);
+                case SyntaxKind.IfStatement:
+                    return emitIfStatement(<IfStatement>node);
+                case SyntaxKind.DoStatement:
+                    return emitDoStatement(<DoStatement>node);
+                case SyntaxKind.WhileStatement:
+                    return emitWhileStatement(<WhileStatement>node);
+                case SyntaxKind.ForStatement:
+                    return emitForStatement(<ForStatement>node);
+                case SyntaxKind.ForInStatement:
+                    return emitForInStatement(<ForInStatement>node);
+                case SyntaxKind.ForOfStatement:
+                    return emitForOfStatement(<ForOfStatement>node);
+                case SyntaxKind.ContinueStatement:
+                    return emitContinueStatement(<ContinueStatement>node);
+                case SyntaxKind.BreakStatement:
+                    return emitBreakStatement(<BreakStatement>node);
+                case SyntaxKind.ReturnStatement:
+                    return emitReturnStatement(<ReturnStatement>node);
+                case SyntaxKind.WithStatement:
+                    return emitWithStatement(<WithStatement>node);
+                case SyntaxKind.SwitchStatement:
+                    return emitSwitchStatement(<SwitchStatement>node);
+                case SyntaxKind.LabeledStatement:
+                    return emitLabeledStatement(<LabeledStatement>node);
+                case SyntaxKind.ThrowStatement:
+                    return emitThrowStatement(<ThrowStatement>node);
+                case SyntaxKind.TryStatement:
+                    return emitTryStatement(<TryStatement>node);
+                case SyntaxKind.DebuggerStatement:
+                    return emitDebuggerStatement(<DebuggerStatement>node);
+
+                // Declarations
+                case SyntaxKind.VariableDeclaration:
+                    return emitVariableDeclaration(<VariableDeclaration>node);
+                case SyntaxKind.VariableDeclarationList:
+                    return emitVariableDeclarationList(<VariableDeclarationList>node);
+                case SyntaxKind.FunctionDeclaration:
+                    return emitFunctionDeclaration(<FunctionDeclaration>node);
+                case SyntaxKind.ClassDeclaration:
+                    return emitClassDeclaration(<ClassDeclaration>node);
+                case SyntaxKind.InterfaceDeclaration:
+                    return emitInterfaceDeclaration(<InterfaceDeclaration>node);
+                case SyntaxKind.TypeAliasDeclaration:
+                    return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);
+                case SyntaxKind.EnumDeclaration:
+                    return emitEnumDeclaration(<EnumDeclaration>node);
+                case SyntaxKind.ModuleDeclaration:
+                    return emitModuleDeclaration(<ModuleDeclaration>node);
+                case SyntaxKind.ModuleBlock:
+                    return emitModuleBlock(<ModuleBlock>node);
+                case SyntaxKind.CaseBlock:
+                    return emitCaseBlock(<CaseBlock>node);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                case SyntaxKind.ImportDeclaration:
+                    return emitImportDeclaration(<ImportDeclaration>node);
+                case SyntaxKind.ImportClause:
+                    return emitImportClause(<ImportClause>node);
+                case SyntaxKind.NamespaceImport:
+                    return emitNamespaceImport(<NamespaceImport>node);
+                case SyntaxKind.NamedImports:
+                    return emitNamedImports(<NamedImports>node);
+                case SyntaxKind.ImportSpecifier:
+                    return emitImportSpecifier(<ImportSpecifier>node);
+                case SyntaxKind.ExportAssignment:
+                    return emitExportAssignment(<ExportAssignment>node);
+                case SyntaxKind.ExportDeclaration:
+                    return emitExportDeclaration(<ExportDeclaration>node);
+                case SyntaxKind.NamedExports:
+                    return emitNamedExports(<NamedExports>node);
+                case SyntaxKind.ExportSpecifier:
+                    return emitExportSpecifier(<ExportSpecifier>node);
+                case SyntaxKind.MissingDeclaration:
+                    return;
+
+                // Module references
+                case SyntaxKind.ExternalModuleReference:
+                    return emitExternalModuleReference(<ExternalModuleReference>node);
+
+                // JSX (non-expression)
+                case SyntaxKind.JsxText:
+                    return emitJsxText(<JsxText>node);
+                case SyntaxKind.JsxOpeningElement:
+                    return emitJsxOpeningElement(<JsxOpeningElement>node);
+                case SyntaxKind.JsxClosingElement:
+                    return emitJsxClosingElement(<JsxClosingElement>node);
+                case SyntaxKind.JsxAttribute:
+                    return emitJsxAttribute(<JsxAttribute>node);
+                case SyntaxKind.JsxSpreadAttribute:
+                    return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);
+                case SyntaxKind.JsxExpression:
+                    return emitJsxExpression(<JsxExpression>node);
+
+                // Clauses
+                case SyntaxKind.CaseClause:
+                    return emitCaseClause(<CaseClause>node);
+                case SyntaxKind.DefaultClause:
+                    return emitDefaultClause(<DefaultClause>node);
+                case SyntaxKind.HeritageClause:
+                    return emitHeritageClause(<HeritageClause>node);
+                case SyntaxKind.CatchClause:
+                    return emitCatchClause(<CatchClause>node);
+
+                // Property assignments
+                case SyntaxKind.PropertyAssignment:
+                    return emitPropertyAssignment(<PropertyAssignment>node);
+                case SyntaxKind.ShorthandPropertyAssignment:
+                    return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);
+                case SyntaxKind.SpreadAssignment:
+                    return emitSpreadAssignment(node as SpreadAssignment);
+
+                // Enum
+                case SyntaxKind.EnumMember:
+                    return emitEnumMember(<EnumMember>node);
+
+                // JSDoc nodes (ignored)
+                // Transformation nodes (ignored)
+            }
+
+            // If the node is an expression, try to emit it as an expression with
+            // substitution.
+            if (isExpression(node)) {
+                return pipelineEmitWithSubstitution(EmitHint.Expression, node);
+            }
+        }
+
+        function pipelineEmitExpression(node: Node): void {
+            const kind = node.kind;
+            switch (kind) {
+                // Literals
+                case SyntaxKind.NumericLiteral:
+                    return emitNumericLiteral(<NumericLiteral>node);
+
+                case SyntaxKind.StringLiteral:
+                case SyntaxKind.RegularExpressionLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    return emitLiteral(<LiteralExpression>node);
+
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(<Identifier>node);
+
+                // Reserved words
+                case SyntaxKind.FalseKeyword:
+                case SyntaxKind.NullKeyword:
+                case SyntaxKind.SuperKeyword:
+                case SyntaxKind.TrueKeyword:
+                case SyntaxKind.ThisKeyword:
+                    writeTokenText(kind);
+                    return;
+
+                // Expressions
+                case SyntaxKind.ArrayLiteralExpression:
+                    return emitArrayLiteralExpression(<ArrayLiteralExpression>node);
+                case SyntaxKind.ObjectLiteralExpression:
+                    return emitObjectLiteralExpression(<ObjectLiteralExpression>node);
+                case SyntaxKind.PropertyAccessExpression:
+                    return emitPropertyAccessExpression(<PropertyAccessExpression>node);
+                case SyntaxKind.ElementAccessExpression:
+                    return emitElementAccessExpression(<ElementAccessExpression>node);
+                case SyntaxKind.CallExpression:
+                    return emitCallExpression(<CallExpression>node);
+                case SyntaxKind.NewExpression:
+                    return emitNewExpression(<NewExpression>node);
+                case SyntaxKind.TaggedTemplateExpression:
+                    return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
+                case SyntaxKind.TypeAssertionExpression:
+                    return emitTypeAssertionExpression(<TypeAssertion>node);
+                case SyntaxKind.ParenthesizedExpression:
+                    return emitParenthesizedExpression(<ParenthesizedExpression>node);
+                case SyntaxKind.FunctionExpression:
+                    return emitFunctionExpression(<FunctionExpression>node);
+                case SyntaxKind.ArrowFunction:
+                    return emitArrowFunction(<ArrowFunction>node);
+                case SyntaxKind.DeleteExpression:
+                    return emitDeleteExpression(<DeleteExpression>node);
+                case SyntaxKind.TypeOfExpression:
+                    return emitTypeOfExpression(<TypeOfExpression>node);
+                case SyntaxKind.VoidExpression:
+                    return emitVoidExpression(<VoidExpression>node);
+                case SyntaxKind.AwaitExpression:
+                    return emitAwaitExpression(<AwaitExpression>node);
+                case SyntaxKind.PrefixUnaryExpression:
+                    return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);
+                case SyntaxKind.PostfixUnaryExpression:
+                    return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);
+                case SyntaxKind.BinaryExpression:
+                    return emitBinaryExpression(<BinaryExpression>node);
+                case SyntaxKind.ConditionalExpression:
+                    return emitConditionalExpression(<ConditionalExpression>node);
+                case SyntaxKind.TemplateExpression:
+                    return emitTemplateExpression(<TemplateExpression>node);
+                case SyntaxKind.YieldExpression:
+                    return emitYieldExpression(<YieldExpression>node);
+                case SyntaxKind.SpreadElement:
+                    return emitSpreadExpression(<SpreadElement>node);
+                case SyntaxKind.ClassExpression:
+                    return emitClassExpression(<ClassExpression>node);
+                case SyntaxKind.OmittedExpression:
+                    return;
+                case SyntaxKind.AsExpression:
+                    return emitAsExpression(<AsExpression>node);
+                case SyntaxKind.NonNullExpression:
+                    return emitNonNullExpression(<NonNullExpression>node);
+                case SyntaxKind.MetaProperty:
+                    return emitMetaProperty(<MetaProperty>node);
+
+                // JSX
+                case SyntaxKind.JsxElement:
+                    return emitJsxElement(<JsxElement>node);
+                case SyntaxKind.JsxSelfClosingElement:
+                    return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);
+
+                // Transformation nodes
+                case SyntaxKind.PartiallyEmittedExpression:
+                    return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
+            }
+        }
+
+        function emitBodyIndirect(node: Node, elements: NodeArray<Node>, emitCallback: (node: Node) => void): void {
+            if (onEmitDetachedCommentsOfNode) {
+                onEmitDetachedCommentsOfNode(node, elements, emitCallback);
+            }
+            else {
+                emitCallback(node);
+            }
+        }
+
+        function emitHelpersIndirect(node: Node) {
+            if (onEmitHelpers) {
+                onEmitHelpers(node, writeLines);
+            }
+        }
+
+        //
+        // Literals/Pseudo-literals
+        //
+
+        // SyntaxKind.NumericLiteral
+        function emitNumericLiteral(node: NumericLiteral) {
+            emitLiteral(node);
+            if (node.trailingComment) {
+                write(` /*${node.trailingComment}*/`);
+            }
+        }
+
+        // SyntaxKind.StringLiteral
+        // SyntaxKind.RegularExpressionLiteral
+        // SyntaxKind.NoSubstitutionTemplateLiteral
+        // SyntaxKind.TemplateHead
+        // SyntaxKind.TemplateMiddle
+        // SyntaxKind.TemplateTail
+        function emitLiteral(node: LiteralLikeNode) {
+            const text = getLiteralTextOfNode(node);
+            if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap)
+                && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
+                writer.writeLiteral(text);
+            }
+            else {
+                write(text);
+            }
+        }
+
+        //
+        // Identifiers
+        //
+
+        function emitIdentifier(node: Identifier) {
+            write(getTextOfNode(node, /*includeTrivia*/ false));
+        }
+
+        //
+        // Names
+        //
+
+        function emitQualifiedName(node: QualifiedName) {
+            emitEntityName(node.left);
+            write(".");
+            emit(node.right);
+        }
+
+        function emitEntityName(node: EntityName) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        function emitComputedPropertyName(node: ComputedPropertyName) {
+            write("[");
+            emitExpression(node.expression);
+            write("]");
+        }
+
+        //
+        // Signature elements
+        //
+
+        function emitTypeParameter(node: TypeParameterDeclaration) {
+            emit(node.name);
+            emitWithPrefix(" extends ", node.constraint);
+        }
+
+        function emitParameter(node: ParameterDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            writeIfPresent(node.dotDotDotToken, "...");
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitExpressionWithPrefix(" = ", node.initializer);
+            emitWithPrefix(": ", node.type);
+        }
+
+        function emitDecorator(decorator: Decorator) {
+            write("@");
+            emitExpression(decorator.expression);
+        }
+
+        //
+        // Type members
+        //
+
+        function emitPropertySignature(node: PropertySignature) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitPropertyDeclaration(node: PropertyDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            emitWithPrefix(": ", node.type);
+            emitExpressionWithPrefix(" = ", node.initializer);
+            write(";");
+        }
+
+        function emitMethodSignature(node: MethodSignature) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitMethodDeclaration(node: MethodDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            writeIfPresent(node.asteriskToken, "*");
+            emit(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitConstructor(node: ConstructorDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("constructor");
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitAccessorDeclaration(node: AccessorDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write(node.kind === SyntaxKind.GetAccessor ? "get " : "set ");
+            emit(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitCallSignature(node: CallSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitConstructSignature(node: ConstructSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("new ");
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitIndexSignature(node: IndexSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitParametersForIndexSignature(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitSemicolonClassElement() {
+            write(";");
+        }
+
+        //
+        // Types
+        //
+
+        function emitTypePredicate(node: TypePredicateNode) {
+            emit(node.parameterName);
+            write(" is ");
+            emit(node.type);
+        }
+
+        function emitTypeReference(node: TypeReferenceNode) {
+            emit(node.typeName);
+            emitTypeArguments(node, node.typeArguments);
+        }
+
+        function emitFunctionType(node: FunctionTypeNode) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            write(" => ");
+            emit(node.type);
+        }
+
+        function emitConstructorType(node: ConstructorTypeNode) {
+            write("new ");
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            write(" => ");
+            emit(node.type);
+        }
+
+        function emitTypeQuery(node: TypeQueryNode) {
+            write("typeof ");
+            emit(node.exprName);
+        }
+
+        function emitTypeLiteral(node: TypeLiteralNode) {
+            write("{");
+            emitList(node, node.members, ListFormat.TypeLiteralMembers);
+            write("}");
+        }
+
+        function emitArrayType(node: ArrayTypeNode) {
+            emit(node.elementType);
+            write("[]");
+        }
+
+        function emitTupleType(node: TupleTypeNode) {
+            write("[");
+            emitList(node, node.elementTypes, ListFormat.TupleTypeElements);
+            write("]");
+        }
+
+        function emitUnionType(node: UnionTypeNode) {
+            emitList(node, node.types, ListFormat.UnionTypeConstituents);
+        }
+
+        function emitIntersectionType(node: IntersectionTypeNode) {
+            emitList(node, node.types, ListFormat.IntersectionTypeConstituents);
+        }
+
+        function emitParenthesizedType(node: ParenthesizedTypeNode) {
+            write("(");
+            emit(node.type);
+            write(")");
+        }
+
+        function emitThisType() {
+            write("this");
+        }
+
+        function emitTypeOperator(node: TypeOperatorNode) {
+            writeTokenText(node.operator);
+            write(" ");
+            emit(node.type);
+        }
+
+        function emitIndexedAccessType(node: IndexedAccessTypeNode) {
+            emit(node.objectType);
+            write("[");
+            emit(node.indexType);
+            write("]");
+        }
+
+        function emitMappedType(node: MappedTypeNode) {
+            write("{");
+            writeLine();
+            increaseIndent();
+            writeIfPresent(node.readonlyToken, "readonly ");
+            write("[");
+            emit(node.typeParameter.name);
+            write(" in ");
+            emit(node.typeParameter.constraint);
+            write("]");
+            writeIfPresent(node.questionToken, "?");
+            write(": ");
+            emit(node.type);
+            write(";");
+            writeLine();
+            decreaseIndent();
+            write("}");
+        }
+
+        function emitLiteralType(node: LiteralTypeNode) {
+            emitExpression(node.literal);
+        }
+
+        //
+        // Binding patterns
+        //
+
+        function emitObjectBindingPattern(node: ObjectBindingPattern) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("{}");
+            }
+            else {
+                write("{");
+                emitList(node, elements, ListFormat.ObjectBindingPatternElements);
+                write("}");
+            }
+        }
+
+        function emitArrayBindingPattern(node: ArrayBindingPattern) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("[]");
+            }
+            else {
+                write("[");
+                emitList(node, node.elements, ListFormat.ArrayBindingPatternElements);
+                write("]");
+            }
+        }
+
+        function emitBindingElement(node: BindingElement) {
+            emitWithSuffix(node.propertyName, ": ");
+            writeIfPresent(node.dotDotDotToken, "...");
+            emit(node.name);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        //
+        // Expressions
+        //
+
+        function emitArrayLiteralExpression(node: ArrayLiteralExpression) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("[]");
+            }
+            else {
+                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
+                emitExpressionList(node, elements, ListFormat.ArrayLiteralExpressionElements | preferNewLine);
+            }
+        }
+
+        function emitObjectLiteralExpression(node: ObjectLiteralExpression) {
+            const properties = node.properties;
+            if (properties.length === 0) {
+                write("{}");
+            }
+            else {
+                const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+                if (indentedFlag) {
+                    increaseIndent();
+                }
+
+                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
+                const allowTrailingComma = languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None;
+                emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine);
+
+                if (indentedFlag) {
+                    decreaseIndent();
+                }
+            }
+        }
+
+        function emitPropertyAccessExpression(node: PropertyAccessExpression) {
+            let indentBeforeDot = false;
+            let indentAfterDot = false;
+            if (!(getEmitFlags(node) & EmitFlags.NoIndentation)) {
+                const dotRangeStart = node.expression.end;
+                const dotRangeEnd = skipTrivia(currentSourceFile.text, node.expression.end) + 1;
+                const dotToken = <Node>{ kind: SyntaxKind.DotToken, pos: dotRangeStart, end: dotRangeEnd };
+                indentBeforeDot = needsIndentation(node, node.expression, dotToken);
+                indentAfterDot = needsIndentation(node, dotToken, node.name);
+            }
+
+            emitExpression(node.expression);
+            increaseIndentIf(indentBeforeDot);
+
+            const shouldEmitDotDot = !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
+            write(shouldEmitDotDot ? ".." : ".");
+
+            increaseIndentIf(indentAfterDot);
+            emit(node.name);
+            decreaseIndentIf(indentBeforeDot, indentAfterDot);
+        }
+
+        // 1..toString is a valid property access, emit a dot after the literal
+        // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal
+        function needsDotDotForPropertyAccess(expression: Expression) {
+            if (expression.kind === SyntaxKind.NumericLiteral) {
+                // check if numeric literal is a decimal literal that was originally written with a dot
+                const text = getLiteralTextOfNode(<LiteralExpression>expression);
+                return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None
+                    && !(<LiteralExpression>expression).isOctalLiteral
+                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
+            }
+            else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
+                // check if constant enum value is integer
+                const constantValue = getConstantValue(expression);
+                // isFinite handles cases when constantValue is undefined
+                return isFinite(constantValue)
+                    && Math.floor(constantValue) === constantValue
+                    && compilerOptions.removeComments;
+            }
+        }
+
+        function emitElementAccessExpression(node: ElementAccessExpression) {
+            emitExpression(node.expression);
+            write("[");
+            emitExpression(node.argumentExpression);
+            write("]");
+        }
+
+        function emitCallExpression(node: CallExpression) {
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+            emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
+        }
+
+        function emitNewExpression(node: NewExpression) {
+            write("new ");
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+            emitExpressionList(node, node.arguments, ListFormat.NewExpressionArguments);
+        }
+
+        function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
+            emitExpression(node.tag);
+            write(" ");
+            emitExpression(node.template);
+        }
+
+        function emitTypeAssertionExpression(node: TypeAssertion) {
+            write("<");
+            emit(node.type);
+            write(">");
+            emitExpression(node.expression);
+        }
+
+        function emitParenthesizedExpression(node: ParenthesizedExpression) {
+            write("(");
+            emitExpression(node.expression);
+            write(")");
+        }
+
+        function emitFunctionExpression(node: FunctionExpression) {
+            emitFunctionDeclarationOrExpression(node);
+        }
+
+        function emitArrowFunction(node: ArrowFunction) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitSignatureAndBody(node, emitArrowFunctionHead);
+        }
+
+        function emitArrowFunctionHead(node: ArrowFunction) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(" =>");
+        }
+
+        function emitDeleteExpression(node: DeleteExpression) {
+            write("delete ");
+            emitExpression(node.expression);
+        }
+
+        function emitTypeOfExpression(node: TypeOfExpression) {
+            write("typeof ");
+            emitExpression(node.expression);
+        }
+
+        function emitVoidExpression(node: VoidExpression) {
+            write("void ");
+            emitExpression(node.expression);
+        }
+
+        function emitAwaitExpression(node: AwaitExpression) {
+            write("await ");
+            emitExpression(node.expression);
+        }
+
+        function emitPrefixUnaryExpression(node: PrefixUnaryExpression) {
+            writeTokenText(node.operator);
+            if (shouldEmitWhitespaceBeforeOperand(node)) {
+                write(" ");
+            }
+            emitExpression(node.operand);
+        }
+
+        function shouldEmitWhitespaceBeforeOperand(node: PrefixUnaryExpression) {
+            // In some cases, we need to emit a space between the operator and the operand. One obvious case
+            // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
+            // and minus expressions in certain cases. Specifically, consider the following two cases (parens
+            // are just for clarity of exposition, and not part of the source code):
+            //
+            //  (+(+1))
+            //  (+(++1))
+            //
+            // We need to emit a space in both cases. In the first case, the absence of a space will make
+            // the resulting expression a prefix increment operation. And in the second, it will make the resulting
+            // expression a prefix increment whose operand is a plus expression - (++(+x))
+            // The same is true of minus of course.
+            const operand = node.operand;
+            return operand.kind === SyntaxKind.PrefixUnaryExpression
+                && ((node.operator === SyntaxKind.PlusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusPlusToken))
+                || (node.operator === SyntaxKind.MinusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusMinusToken)));
+        }
+
+        function emitPostfixUnaryExpression(node: PostfixUnaryExpression) {
+            emitExpression(node.operand);
+            writeTokenText(node.operator);
+        }
+
+        function emitBinaryExpression(node: BinaryExpression) {
+            const isCommaOperator = node.operatorToken.kind !== SyntaxKind.CommaToken;
+            const indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken);
+            const indentAfterOperator = needsIndentation(node, node.operatorToken, node.right);
+
+            emitExpression(node.left);
+            increaseIndentIf(indentBeforeOperator, isCommaOperator ? " " : undefined);
+            writeTokenText(node.operatorToken.kind);
+            increaseIndentIf(indentAfterOperator, " ");
+            emitExpression(node.right);
+            decreaseIndentIf(indentBeforeOperator, indentAfterOperator);
+        }
+
+        function emitConditionalExpression(node: ConditionalExpression) {
+            const indentBeforeQuestion = needsIndentation(node, node.condition, node.questionToken);
+            const indentAfterQuestion = needsIndentation(node, node.questionToken, node.whenTrue);
+            const indentBeforeColon = needsIndentation(node, node.whenTrue, node.colonToken);
+            const indentAfterColon = needsIndentation(node, node.colonToken, node.whenFalse);
+
+            emitExpression(node.condition);
+            increaseIndentIf(indentBeforeQuestion, " ");
+            write("?");
+            increaseIndentIf(indentAfterQuestion, " ");
+            emitExpression(node.whenTrue);
+            decreaseIndentIf(indentBeforeQuestion, indentAfterQuestion);
+
+            increaseIndentIf(indentBeforeColon, " ");
+            write(":");
+            increaseIndentIf(indentAfterColon, " ");
+            emitExpression(node.whenFalse);
+            decreaseIndentIf(indentBeforeColon, indentAfterColon);
+        }
+
+        function emitTemplateExpression(node: TemplateExpression) {
+            emit(node.head);
+            emitList(node, node.templateSpans, ListFormat.TemplateExpressionSpans);
+        }
+
+        function emitYieldExpression(node: YieldExpression) {
+            write(node.asteriskToken ? "yield*" : "yield");
+            emitExpressionWithPrefix(" ", node.expression);
+        }
+
+        function emitSpreadExpression(node: SpreadElement) {
+            write("...");
+            emitExpression(node.expression);
+        }
+
+        function emitClassExpression(node: ClassExpression) {
+            emitClassDeclarationOrExpression(node);
+        }
+
+        function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+        }
+
+        function emitAsExpression(node: AsExpression) {
+            emitExpression(node.expression);
+            if (node.type) {
+                write(" as ");
+                emit(node.type);
+            }
+        }
+
+        function emitNonNullExpression(node: NonNullExpression) {
+            emitExpression(node.expression);
+            write("!");
+        }
+
+        function emitMetaProperty(node: MetaProperty) {
+            writeToken(node.keywordToken, node.pos);
+            write(".");
+            emit(node.name);
+        }
+
+        //
+        // Misc
+        //
+
+        function emitTemplateSpan(node: TemplateSpan) {
+            emitExpression(node.expression);
+            emit(node.literal);
+        }
+
+        //
+        // Statements
+        //
+
+        function emitBlock(node: Block) {
+            if (isSingleLineEmptyBlock(node)) {
+                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
+                write(" ");
+                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
+            }
+            else {
+                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
+                emitBlockStatements(node);
+                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
+            }
+        }
+
+        function emitBlockStatements(node: BlockLike) {
+            if (getEmitFlags(node) & EmitFlags.SingleLine) {
+                emitList(node, node.statements, ListFormat.SingleLineBlockStatements);
+            }
+            else {
+                emitList(node, node.statements, ListFormat.MultiLineBlockStatements);
+            }
+        }
+
+        function emitVariableStatement(node: VariableStatement) {
+            emitModifiers(node, node.modifiers);
+            emit(node.declarationList);
+            write(";");
+        }
+
+        function emitEmptyStatement() {
+            write(";");
+        }
+
+        function emitExpressionStatement(node: ExpressionStatement) {
+            emitExpression(node.expression);
+            write(";");
+        }
+
+        function emitIfStatement(node: IfStatement) {
+            const openParenPos = writeToken(SyntaxKind.IfKeyword, node.pos, node);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos, node);
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end, node);
+            emitEmbeddedStatement(node, node.thenStatement);
+            if (node.elseStatement) {
+                writeLineOrSpace(node);
+                writeToken(SyntaxKind.ElseKeyword, node.thenStatement.end, node);
+                if (node.elseStatement.kind === SyntaxKind.IfStatement) {
+                    write(" ");
+                    emit(node.elseStatement);
+                }
+                else {
+                    emitEmbeddedStatement(node, node.elseStatement);
+                }
+            }
+        }
+
+        function emitDoStatement(node: DoStatement) {
+            write("do");
+            emitEmbeddedStatement(node, node.statement);
+            if (isBlock(node.statement)) {
+                write(" ");
+            }
+            else {
+                writeLineOrSpace(node);
+            }
+
+            write("while (");
+            emitExpression(node.expression);
+            write(");");
+        }
+
+        function emitWhileStatement(node: WhileStatement) {
+            write("while (");
+            emitExpression(node.expression);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForStatement(node: ForStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos, /*contextNode*/ node);
+            emitForBinding(node.initializer);
+            write(";");
+            emitExpressionWithPrefix(" ", node.condition);
+            write(";");
+            emitExpressionWithPrefix(" ", node.incrementor);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForInStatement(node: ForInStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitForBinding(node.initializer);
+            write(" in ");
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForOfStatement(node: ForOfStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitForBinding(node.initializer);
+            write(" of ");
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForBinding(node: VariableDeclarationList | Expression) {
+            if (node !== undefined) {
+                if (node.kind === SyntaxKind.VariableDeclarationList) {
+                    emit(node);
+                }
+                else {
+                    emitExpression(<Expression>node);
+                }
+            }
+        }
+
+        function emitContinueStatement(node: ContinueStatement) {
+            writeToken(SyntaxKind.ContinueKeyword, node.pos);
+            emitWithPrefix(" ", node.label);
+            write(";");
+        }
+
+        function emitBreakStatement(node: BreakStatement) {
+            writeToken(SyntaxKind.BreakKeyword, node.pos);
+            emitWithPrefix(" ", node.label);
+            write(";");
+        }
+
+        function emitReturnStatement(node: ReturnStatement) {
+            writeToken(SyntaxKind.ReturnKeyword, node.pos, /*contextNode*/ node);
+            emitExpressionWithPrefix(" ", node.expression);
+            write(";");
+        }
+
+        function emitWithStatement(node: WithStatement) {
+            write("with (");
+            emitExpression(node.expression);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitSwitchStatement(node: SwitchStatement) {
+            const openParenPos = writeToken(SyntaxKind.SwitchKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            write(" ");
+            emit(node.caseBlock);
+        }
+
+        function emitLabeledStatement(node: LabeledStatement) {
+            emit(node.label);
+            write(": ");
+            emit(node.statement);
+        }
+
+        function emitThrowStatement(node: ThrowStatement) {
+            write("throw");
+            emitExpressionWithPrefix(" ", node.expression);
+            write(";");
+        }
+
+        function emitTryStatement(node: TryStatement) {
+            write("try ");
+            emit(node.tryBlock);
+            if (node.catchClause) {
+                writeLineOrSpace(node);
+                emit(node.catchClause);
+            }
+            if (node.finallyBlock) {
+                writeLineOrSpace(node);
+                write("finally ");
+                emit(node.finallyBlock);
+            }
+        }
+
+        function emitDebuggerStatement(node: DebuggerStatement) {
+            writeToken(SyntaxKind.DebuggerKeyword, node.pos);
+            write(";");
+        }
+
+        //
+        // Declarations
+        //
+
+        function emitVariableDeclaration(node: VariableDeclaration) {
+            emit(node.name);
+            emitWithPrefix(": ", node.type);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        function emitVariableDeclarationList(node: VariableDeclarationList) {
+            write(isLet(node) ? "let " : isConst(node) ? "const " : "var ");
+            emitList(node, node.declarations, ListFormat.VariableDeclarationList);
+        }
+
+        function emitFunctionDeclaration(node: FunctionDeclaration) {
+            emitFunctionDeclarationOrExpression(node);
+        }
+
+        function emitFunctionDeclarationOrExpression(node: FunctionDeclaration | FunctionExpression) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write(node.asteriskToken ? "function* " : "function ");
+            emitIdentifierName(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitSignatureAndBody(node: FunctionLikeDeclaration, emitSignatureHead: (node: SignatureDeclaration) => void) {
+            const body = node.body;
+            if (body) {
+                if (isBlock(body)) {
+                    const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+                    if (indentedFlag) {
+                        increaseIndent();
+                    }
+
+                    if (getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
+                        emitSignatureHead(node);
+                        emitBlockFunctionBody(body);
+                    }
+                    else {
+                        pushNameGenerationScope();
+                        emitSignatureHead(node);
+                        emitBlockFunctionBody(body);
+                        popNameGenerationScope();
+                    }
+
+                    if (indentedFlag) {
+                        decreaseIndent();
+                    }
+                }
+                else {
+                    emitSignatureHead(node);
+                    write(" ");
+                    emitExpression(body);
+                }
+            }
+            else {
+                emitSignatureHead(node);
+                write(";");
+            }
+
+        }
+
+        function emitSignatureHead(node: FunctionDeclaration | FunctionExpression | MethodDeclaration | AccessorDeclaration | ConstructorDeclaration) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+        }
+
+        function shouldEmitBlockFunctionBodyOnSingleLine(body: Block) {
+            // We must emit a function body as a single-line body in the following case:
+            // * The body has NodeEmitFlags.SingleLine specified.
+
+            // We must emit a function body as a multi-line body in the following cases:
+            // * The body is explicitly marked as multi-line.
+            // * A non-synthesized body's start and end position are on different lines.
+            // * Any statement in the body starts on a new line.
+
+            if (getEmitFlags(body) & EmitFlags.SingleLine) {
+                return true;
+            }
+
+            if (body.multiLine) {
+                return false;
+            }
+
+            if (!nodeIsSynthesized(body) && !rangeIsOnSingleLine(body, currentSourceFile)) {
+                return false;
+            }
+
+            if (shouldWriteLeadingLineTerminator(body, body.statements, ListFormat.PreserveLines)
+                || shouldWriteClosingLineTerminator(body, body.statements, ListFormat.PreserveLines)) {
+                return false;
+            }
+
+            let previousStatement: Statement;
+            for (const statement of body.statements) {
+                if (shouldWriteSeparatingLineTerminator(previousStatement, statement, ListFormat.PreserveLines)) {
+                    return false;
+                }
+
+                previousStatement = statement;
+            }
+
+            return true;
+        }
+
+        function emitBlockFunctionBody(body: Block) {
+            write(" {");
+            increaseIndent();
+
+            const emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body)
+                ? emitBlockFunctionBodyOnSingleLine
+                : emitBlockFunctionBodyWorker;
+
+            emitBodyIndirect(body, body.statements, emitBlockFunctionBody);
+
+            decreaseIndent();
+            writeToken(SyntaxKind.CloseBraceToken, body.statements.end, body);
+        }
+
+        function emitBlockFunctionBodyOnSingleLine(body: Block) {
+            emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true);
+        }
+
+        function emitBlockFunctionBodyWorker(body: Block, emitBlockFunctionBodyOnSingleLine?: boolean) {
+            // Emit all the prologue directives (like "use strict").
+            const statementOffset = emitPrologueDirectives(body.statements, /*startWithNewLine*/ true);
+            const pos = writer.getTextPos();
+            emitHelpersIndirect(body);
+            if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) {
+                decreaseIndent();
+                emitList(body, body.statements, ListFormat.SingleLineFunctionBodyStatements);
+                increaseIndent();
+            }
+            else {
+                emitList(body, body.statements, ListFormat.MultiLineFunctionBodyStatements, statementOffset);
+            }
+        }
+
+        function emitClassDeclaration(node: ClassDeclaration) {
+            emitClassDeclarationOrExpression(node);
+        }
+
+        function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("class");
+            emitNodeWithPrefix(" ", node.name, emitIdentifierName);
+
+            const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+            if (indentedFlag) {
+                increaseIndent();
+            }
+
+            emitTypeParameters(node, node.typeParameters);
+            emitList(node, node.heritageClauses, ListFormat.ClassHeritageClauses);
+
+            pushNameGenerationScope();
+            write(" {");
+            emitList(node, node.members, ListFormat.ClassMembers);
+            write("}");
+            popNameGenerationScope();
+
+            if (indentedFlag) {
+                decreaseIndent();
+            }
+        }
+
+        function emitInterfaceDeclaration(node: InterfaceDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("interface ");
+            emit(node.name);
+            emitTypeParameters(node, node.typeParameters);
+            emitList(node, node.heritageClauses, ListFormat.HeritageClauses);
+            write(" {");
+            emitList(node, node.members, ListFormat.InterfaceMembers);
+            write("}");
+        }
+
+        function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("type ");
+            emit(node.name);
+            emitTypeParameters(node, node.typeParameters);
+            write(" = ");
+            emit(node.type);
+            write(";");
+        }
+
+        function emitEnumDeclaration(node: EnumDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("enum ");
+            emit(node.name);
+            pushNameGenerationScope();
+            write(" {");
+            emitList(node, node.members, ListFormat.EnumMembers);
+            write("}");
+            popNameGenerationScope();
+        }
+
+        function emitModuleDeclaration(node: ModuleDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
+            emit(node.name);
+
+            let body = node.body;
+            while (body.kind === SyntaxKind.ModuleDeclaration) {
+                write(".");
+                emit((<ModuleDeclaration>body).name);
+                body = (<ModuleDeclaration>body).body;
+            }
+
+            write(" ");
+            emit(body);
+        }
+
+        function emitModuleBlock(node: ModuleBlock) {
+            if (isEmptyBlock(node)) {
+                write("{ }");
+            }
+            else {
+                pushNameGenerationScope();
+                write("{");
+                increaseIndent();
+                emitBlockStatements(node);
+                write("}");
+                popNameGenerationScope();
+            }
+        }
+
+        function emitCaseBlock(node: CaseBlock) {
+            writeToken(SyntaxKind.OpenBraceToken, node.pos);
+            emitList(node, node.clauses, ListFormat.CaseBlockClauses);
+            writeToken(SyntaxKind.CloseBraceToken, node.clauses.end);
+        }
+
+        function emitImportEqualsDeclaration(node: ImportEqualsDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("import ");
+            emit(node.name);
+            write(" = ");
+            emitModuleReference(node.moduleReference);
+            write(";");
+        }
+
+        function emitModuleReference(node: ModuleReference) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        function emitImportDeclaration(node: ImportDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("import ");
+            if (node.importClause) {
+                emit(node.importClause);
+                write(" from ");
+            }
+            emitExpression(node.moduleSpecifier);
+            write(";");
+        }
+
+        function emitImportClause(node: ImportClause) {
+            emit(node.name);
+            if (node.name && node.namedBindings) {
+                write(", ");
+            }
+            emit(node.namedBindings);
+        }
+
+        function emitNamespaceImport(node: NamespaceImport) {
+            write("* as ");
+            emit(node.name);
+        }
+
+        function emitNamedImports(node: NamedImports) {
+            emitNamedImportsOrExports(node);
+        }
+
+        function emitImportSpecifier(node: ImportSpecifier) {
+            emitImportOrExportSpecifier(node);
+        }
+
+        function emitExportAssignment(node: ExportAssignment) {
+            write(node.isExportEquals ? "export = " : "export default ");
+            emitExpression(node.expression);
+            write(";");
+        }
+
+        function emitExportDeclaration(node: ExportDeclaration) {
+            write("export ");
+            if (node.exportClause) {
+                emit(node.exportClause);
+            }
+            else {
+                write("*");
+            }
+            if (node.moduleSpecifier) {
+                write(" from ");
+                emitExpression(node.moduleSpecifier);
+            }
+            write(";");
+        }
+
+        function emitNamedExports(node: NamedExports) {
+            emitNamedImportsOrExports(node);
+        }
+
+        function emitExportSpecifier(node: ExportSpecifier) {
+            emitImportOrExportSpecifier(node);
+        }
+
+        function emitNamedImportsOrExports(node: NamedImportsOrExports) {
+            write("{");
+            emitList(node, node.elements, ListFormat.NamedImportsOrExportsElements);
+            write("}");
+        }
+
+        function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
+            if (node.propertyName) {
+                emit(node.propertyName);
+                write(" as ");
+            }
+
+            emit(node.name);
+        }
+
+        //
+        // Module references
+        //
+
+        function emitExternalModuleReference(node: ExternalModuleReference) {
+            write("require(");
+            emitExpression(node.expression);
+            write(")");
+        }
+
+        //
+        // JSX
+        //
+
+        function emitJsxElement(node: JsxElement) {
+            emit(node.openingElement);
+            emitList(node, node.children, ListFormat.JsxElementChildren);
+            emit(node.closingElement);
+        }
+
+        function emitJsxSelfClosingElement(node: JsxSelfClosingElement) {
+            write("<");
+            emitJsxTagName(node.tagName);
+            write(" ");
+            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
+            write("/>");
+        }
+
+        function emitJsxOpeningElement(node: JsxOpeningElement) {
+            write("<");
+            emitJsxTagName(node.tagName);
+            writeIfAny(node.attributes, " ");
+            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
+            write(">");
+        }
+
+        function emitJsxText(node: JsxText) {
+            writer.writeLiteral(getTextOfNode(node, /*includeTrivia*/ true));
+        }
+
+        function emitJsxClosingElement(node: JsxClosingElement) {
+            write("</");
+            emitJsxTagName(node.tagName);
+            write(">");
+        }
+
+        function emitJsxAttribute(node: JsxAttribute) {
+            emit(node.name);
+            emitWithPrefix("=", node.initializer);
+        }
+
+        function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {
+            write("{...");
+            emitExpression(node.expression);
+            write("}");
+        }
+
+        function emitJsxExpression(node: JsxExpression) {
+            if (node.expression) {
+                write("{");
+                if (node.dotDotDotToken) {
+                    write("...");
+                }
+                emitExpression(node.expression);
+                write("}");
+            }
+        }
+
+        function emitJsxTagName(node: JsxTagNameExpression) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        //
+        // Clauses
+        //
+
+        function emitCaseClause(node: CaseClause) {
+            write("case ");
+            emitExpression(node.expression);
+            write(":");
+
+            emitCaseOrDefaultClauseStatements(node, node.statements);
+        }
+
+        function emitDefaultClause(node: DefaultClause) {
+            write("default:");
+            emitCaseOrDefaultClauseStatements(node, node.statements);
+        }
+
+        function emitCaseOrDefaultClauseStatements(parentNode: Node, statements: NodeArray<Statement>) {
+            const emitAsSingleStatement =
+                statements.length === 1 &&
+                (
+                    // treat synthesized nodes as located on the same line for emit purposes
+                    nodeIsSynthesized(parentNode) ||
+                    nodeIsSynthesized(statements[0]) ||
+                    rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)
+                );
+
+            if (emitAsSingleStatement) {
+                write(" ");
+                emit(statements[0]);
+            }
+            else {
+                emitList(parentNode, statements, ListFormat.CaseOrDefaultClauseStatements);
+            }
+        }
+
+        function emitHeritageClause(node: HeritageClause) {
+            write(" ");
+            writeTokenText(node.token);
+            write(" ");
+            emitList(node, node.types, ListFormat.HeritageClauseTypes);
+        }
+
+        function emitCatchClause(node: CatchClause) {
+            writeLine();
+            const openParenPos = writeToken(SyntaxKind.CatchKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emit(node.variableDeclaration);
+            writeToken(SyntaxKind.CloseParenToken, node.variableDeclaration ? node.variableDeclaration.end : openParenPos);
+            write(" ");
+            emit(node.block);
+        }
+
+        //
+        // Property assignments
+        //
+
+        function emitPropertyAssignment(node: PropertyAssignment) {
+            emit(node.name);
+            write(": ");
+            // This is to ensure that we emit comment in the following case:
+            //      For example:
+            //          obj = {
+            //              id: /*comment1*/ ()=>void
+            //          }
+            // "comment1" is not considered to be leading comment for node.initializer
+            // but rather a trailing comment on the previous node.
+            const initializer = node.initializer;
+            if (onEmitTrailingCommentsOfPosition && (getEmitFlags(initializer) & EmitFlags.NoLeadingComments) === 0) {
+                const commentRange = getCommentRange(initializer);
+                onEmitTrailingCommentsOfPosition(commentRange.pos);
+            }
+            emitExpression(initializer);
+        }
+
+        function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {
+            emit(node.name);
+            if (node.objectAssignmentInitializer) {
+                write(" = ");
+                emitExpression(node.objectAssignmentInitializer);
+            }
+        }
+
+        function emitSpreadAssignment(node: SpreadAssignment) {
+            if (node.expression) {
+                write("...");
+                emitExpression(node.expression);
+            }
+        }
+
+        //
+        // Enum
+        //
+
+        function emitEnumMember(node: EnumMember) {
+            emit(node.name);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        //
+        // Top-level nodes
+        //
+
+        function emitSourceFile(node: SourceFile) {
+            writeLine();
+            emitShebang();
+            emitBodyIndirect(node, node.statements, emitSourceFileWorker);
+        }
+
+        function emitSourceFileWorker(node: SourceFile) {
+            const statements = node.statements;
+            const statementOffset = emitPrologueDirectives(statements);
+            pushNameGenerationScope();
+            emitHelpersIndirect(node);
+            emitList(node, statements, ListFormat.MultiLine, statementOffset);
+            popNameGenerationScope();
+        }
+
+        // Transformation nodes
+
+        function emitPartiallyEmittedExpression(node: PartiallyEmittedExpression) {
+            emitExpression(node.expression);
+        }
+
+        /**
+         * Emits any prologue directives at the start of a Statement list, returning the
+         * number of prologue directives written to the output.
+         */
+        function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean): number {
+            for (let i = 0; i < statements.length; i++) {
+                if (isPrologueDirective(statements[i])) {
+                    if (startWithNewLine || i > 0) {
+                        writeLine();
+                    }
+                    emit(statements[i]);
+                }
+                else {
+                    // return index of the first non prologue directive
+                    return i;
+                }
+            }
+
+            return statements.length;
+        }
+
+        //
+        // Helpers
+        //
+
+        function emitShebang() {
+            const shebang = getShebang(currentSourceFile.text);
+            if (shebang) {
+                write(shebang);
+                writeLine();
+            }
+        }
+
+        function emitModifiers(node: Node, modifiers: NodeArray<Modifier>) {
+            if (modifiers && modifiers.length) {
+                emitList(node, modifiers, ListFormat.Modifiers);
+                write(" ");
+            }
+        }
+
+        function emitWithPrefix(prefix: string, node: Node) {
+            emitNodeWithPrefix(prefix, node, emit);
+        }
+
+        function emitExpressionWithPrefix(prefix: string, node: Node) {
+            emitNodeWithPrefix(prefix, node, emitExpression);
+        }
+
+        function emitNodeWithPrefix(prefix: string, node: Node, emit: (node: Node) => void) {
+            if (node) {
+                write(prefix);
+                emit(node);
+            }
+        }
+
+        function emitWithSuffix(node: Node, suffix: string) {
+            if (node) {
+                emit(node);
+                write(suffix);
+            }
+        }
+
+        function emitEmbeddedStatement(parent: Node, node: Statement) {
+            if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
+                write(" ");
+                emit(node);
+            }
+            else {
+                writeLine();
+                increaseIndent();
+                emit(node);
+                decreaseIndent();
+            }
+        }
+
+        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator>) {
+            emitList(parentNode, decorators, ListFormat.Decorators);
+        }
+
+        function emitTypeArguments(parentNode: Node, typeArguments: NodeArray<TypeNode>) {
+            emitList(parentNode, typeArguments, ListFormat.TypeArguments);
+        }
+
+        function emitTypeParameters(parentNode: Node, typeParameters: NodeArray<TypeParameterDeclaration>) {
+            emitList(parentNode, typeParameters, ListFormat.TypeParameters);
+        }
+
+        function emitParameters(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            emitList(parentNode, parameters, ListFormat.Parameters);
+        }
+
+        function emitParametersForArrow(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            if (parameters &&
+                parameters.length === 1 &&
+                parameters[0].type === undefined &&
+                parameters[0].pos === parentNode.pos) {
+                emit(parameters[0]);
+            }
+            else {
+                emitParameters(parentNode, parameters);
+            }
+        }
+
+        function emitParametersForIndexSignature(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            emitList(parentNode, parameters, ListFormat.IndexSignatureParameters);
+        }
+
+        function emitList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
+            emitNodeList(emit, parentNode, children, format, start, count);
+        }
+
+        function emitExpressionList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
+            emitNodeList(emitExpression, parentNode, children, format, start, count);
+        }
+
+        function emitNodeList(emit: (node: Node) => void, parentNode: Node, children: NodeArray<Node>, format: ListFormat, start = 0, count = children ? children.length - start : 0) {
+            const isUndefined = children === undefined;
+            if (isUndefined && format & ListFormat.OptionalIfUndefined) {
+                return;
+            }
+
+            const isEmpty = isUndefined || children.length === 0 || start >= children.length || count === 0;
+            if (isEmpty && format & ListFormat.OptionalIfEmpty) {
+                return;
+            }
+
+            if (format & ListFormat.BracketsMask) {
+                write(getOpeningBracket(format));
+            }
+
+            if (isEmpty) {
+                // Write a line terminator if the parent node was multi-line
+                if (format & ListFormat.MultiLine) {
+                    writeLine();
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+            }
+            else {
+                // Write the opening line terminator or leading whitespace.
+                const mayEmitInterveningComments = (format & ListFormat.NoInterveningComments) === 0;
+                let shouldEmitInterveningComments = mayEmitInterveningComments;
+                if (shouldWriteLeadingLineTerminator(parentNode, children, format)) {
+                    writeLine();
+                    shouldEmitInterveningComments = false;
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+
+                // Increase the indent, if requested.
+                if (format & ListFormat.Indented) {
+                    increaseIndent();
+                }
+
+                // Emit each child.
+                let previousSibling: Node;
+                let shouldDecreaseIndentAfterEmit: boolean;
+                const delimiter = getDelimiter(format);
+                for (let i = 0; i < count; i++) {
+                    const child = children[start + i];
+
+                    // Write the delimiter if this is not the first node.
+                    if (previousSibling) {
+                        write(delimiter);
+
+                        // Write either a line terminator or whitespace to separate the elements.
+                        if (shouldWriteSeparatingLineTerminator(previousSibling, child, format)) {
+                            // If a synthesized node in a single-line list starts on a new
+                            // line, we should increase the indent.
+                            if ((format & (ListFormat.LinesMask | ListFormat.Indented)) === ListFormat.SingleLine) {
+                                increaseIndent();
+                                shouldDecreaseIndentAfterEmit = true;
+                            }
+
+                            writeLine();
+                            shouldEmitInterveningComments = false;
+                        }
+                        else if (previousSibling && format & ListFormat.SpaceBetweenSiblings) {
+                            write(" ");
+                        }
+                    }
+
+                    // Emit this child.
+                    if (shouldEmitInterveningComments) {
+                        if (onEmitTrailingCommentsOfPosition) {
+                            const commentRange = getCommentRange(child);
+                            onEmitTrailingCommentsOfPosition(commentRange.pos);
+                        }
+                    }
+                    else {
+                        shouldEmitInterveningComments = mayEmitInterveningComments;
+                    }
+
+                    emit(child);
+
+                    if (shouldDecreaseIndentAfterEmit) {
+                        decreaseIndent();
+                        shouldDecreaseIndentAfterEmit = false;
+                    }
+
+                    previousSibling = child;
+                }
+
+                // Write a trailing comma, if requested.
+                const hasTrailingComma = (format & ListFormat.AllowTrailingComma) && children.hasTrailingComma;
+                if (format & ListFormat.CommaDelimited && hasTrailingComma) {
+                    write(",");
+                }
+
+                // Decrease the indent, if requested.
+                if (format & ListFormat.Indented) {
+                    decreaseIndent();
+                }
+
+                // Write the closing line terminator or closing whitespace.
+                if (shouldWriteClosingLineTerminator(parentNode, children, format)) {
+                    writeLine();
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+            }
+
+            if (format & ListFormat.BracketsMask) {
+                write(getClosingBracket(format));
+            }
+        }
+
+        function writeIfAny(nodes: NodeArray<Node>, text: string) {
+            if (some(nodes)) {
+                write(text);
+            }
+        }
+
+        function writeIfPresent(node: Node, text: string) {
+            if (node) {
+                write(text);
+            }
+        }
+
+        function writeToken(token: SyntaxKind, pos: number, contextNode?: Node) {
+            return onEmitSourceMapOfToken
+                ? onEmitSourceMapOfToken(contextNode, token, pos, writeTokenText)
+                : writeTokenText(token, pos);
+        }
+
+        function writeTokenText(token: SyntaxKind, pos?: number) {
+            const tokenString = tokenToString(token);
+            write(tokenString);
+            return pos < 0 ? pos : pos + tokenString.length;
+        }
+
+        function writeLineOrSpace(node: Node) {
+            if (getEmitFlags(node) & EmitFlags.SingleLine) {
+                write(" ");
+            }
+            else {
+                writeLine();
+            }
+        }
+
+        function writeLines(text: string): void {
+            const lines = text.split(/\r\n?|\n/g);
+            const indentation = guessIndentation(lines);
+            for (let i = 0; i < lines.length; i++) {
+                const line = indentation ? lines[i].slice(indentation) : lines[i];
+                if (line.length) {
+                    writeLine();
+                    write(line);
+                    writeLine();
+                }
+            }
+        }
+
+        function guessIndentation(lines: string[]) {
+            let indentation: number;
+            for (const line of lines) {
+                for (let i = 0; i < line.length && (indentation === undefined || i < indentation); i++) {
+                    if (!isWhiteSpace(line.charCodeAt(i))) {
+                        if (indentation === undefined || i < indentation) {
+                            indentation = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            return indentation;
+        }
+
+        function increaseIndentIf(value: boolean, valueToWriteWhenNotIndenting?: string) {
+            if (value) {
+                increaseIndent();
+                writeLine();
+            }
+            else if (valueToWriteWhenNotIndenting) {
+                write(valueToWriteWhenNotIndenting);
+            }
+        }
+
+        // Helper function to decrease the indent if we previously indented.  Allows multiple
+        // previous indent values to be considered at a time.  This also allows caller to just
+        // call this once, passing in all their appropriate indent values, instead of needing
+        // to call this helper function multiple times.
+        function decreaseIndentIf(value1: boolean, value2?: boolean) {
+            if (value1) {
+                decreaseIndent();
+            }
+            if (value2) {
+                decreaseIndent();
+            }
+        }
+
+        function shouldWriteLeadingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return true;
+            }
+
+            if (format & ListFormat.PreserveLines) {
+                if (format & ListFormat.PreferNewLine) {
+                    return true;
+                }
+
+                const firstChild = children[0];
+                if (firstChild === undefined) {
+                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
+                }
+                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(firstChild)) {
+                    return synthesizedNodeStartsOnNewLine(firstChild, format);
+                }
+                else {
+                    return !rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+
+        function shouldWriteSeparatingLineTerminator(previousNode: Node, nextNode: Node, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return true;
+            }
+            else if (format & ListFormat.PreserveLines) {
+                if (previousNode === undefined || nextNode === undefined) {
+                    return false;
+                }
+                else if (nodeIsSynthesized(previousNode) || nodeIsSynthesized(nextNode)) {
+                    return synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format);
+                }
+                else {
+                    return !rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile);
+                }
+            }
+            else {
+                return nextNode.startsOnNewLine;
+            }
+        }
+
+        function shouldWriteClosingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return (format & ListFormat.NoTrailingNewLine) === 0;
+            }
+            else if (format & ListFormat.PreserveLines) {
+                if (format & ListFormat.PreferNewLine) {
+                    return true;
+                }
+
+                const lastChild = lastOrUndefined(children);
+                if (lastChild === undefined) {
+                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
+                }
+                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(lastChild)) {
+                    return synthesizedNodeStartsOnNewLine(lastChild, format);
+                }
+                else {
+                    return !rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+
+        function synthesizedNodeStartsOnNewLine(node: Node, format?: ListFormat) {
+            if (nodeIsSynthesized(node)) {
+                const startsOnNewLine = node.startsOnNewLine;
+                if (startsOnNewLine === undefined) {
+                    return (format & ListFormat.PreferNewLine) !== 0;
+                }
+
+                return startsOnNewLine;
+            }
+
+            return (format & ListFormat.PreferNewLine) !== 0;
+        }
+
+        function needsIndentation(parent: Node, node1: Node, node2: Node): boolean {
+            parent = skipSynthesizedParentheses(parent);
+            node1 = skipSynthesizedParentheses(node1);
+            node2 = skipSynthesizedParentheses(node2);
+
+            // Always use a newline for synthesized code if the synthesizer desires it.
+            if (node2.startsOnNewLine) {
+                return true;
+            }
+
+            return !nodeIsSynthesized(parent)
+                && !nodeIsSynthesized(node1)
+                && !nodeIsSynthesized(node2)
+                && !rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile);
+        }
+
+        function isSingleLineEmptyBlock(block: Block) {
+            return !block.multiLine
+                && isEmptyBlock(block);
+        }
+
+        function isEmptyBlock(block: BlockLike) {
+            return block.statements.length === 0
+                && rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
+        }
+
+        function skipSynthesizedParentheses(node: Node) {
+            while (node.kind === SyntaxKind.ParenthesizedExpression && nodeIsSynthesized(node)) {
+                node = (<ParenthesizedExpression>node).expression;
+            }
+
+            return node;
+        }
+
+        function getTextOfNode(node: Node, includeTrivia?: boolean): string {
+            if (isGeneratedIdentifier(node)) {
+                return generateName(node);
+            }
+            else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
+                return unescapeIdentifier(node.text);
+            }
+            else if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
+                return getTextOfNode((<StringLiteral>node).textSourceNode, includeTrivia);
+            }
+            else if (isLiteralExpression(node) && (nodeIsSynthesized(node) || !node.parent)) {
+                return node.text;
+            }
+
+            return getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia);
+        }
+
+        function getLiteralTextOfNode(node: LiteralLikeNode): string {
+            if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
+                const textSourceNode = (<StringLiteral>node).textSourceNode;
+                if (isIdentifier(textSourceNode)) {
+                    return "\"" + escapeNonAsciiCharacters(escapeString(getTextOfNode(textSourceNode))) + "\"";
+                }
+                else {
+                    return getLiteralTextOfNode(textSourceNode);
+                }
+            }
+
+            return getLiteralText(node, currentSourceFile, languageVersion);
+        }
+
+        function resetGeneratedNames() {
+            nodeIdToGeneratedName = undefined;
+            autoGeneratedIdToGeneratedName = undefined;
+            generatedNames = undefined;
+            tempFlagsStack = undefined;
+            tempFlags = TempFlags.Auto;
+        }
+
+        function ensureNameGeneration() {
+            if (generatedNames === undefined) {
+                nodeIdToGeneratedName = [];
+                autoGeneratedIdToGeneratedName = [];
+                generatedNames = createMap<string>();
+                tempFlagsStack = [];
+            }
+        }
+
+        /**
+         * Push a new name generation scope.
+         */
+        function pushNameGenerationScope() {
+            ensureNameGeneration();
+            tempFlagsStack.push(tempFlags);
+            tempFlags = 0;
+        }
+
+        /**
+         * Pop the current name generation scope.
+         */
+        function popNameGenerationScope() {
+            ensureNameGeneration();
+            tempFlags = tempFlagsStack.pop();
+        }
+
+        /**
+         * Generate the text for a generated identifier.
+         */
+        function generateName(name: GeneratedIdentifier) {
+            ensureNameGeneration();
+            if (name.autoGenerateKind === GeneratedIdentifierKind.Node) {
+                // Node names generate unique names based on their original node
+                // and are cached based on that node's id.
+                const node = getNodeForGeneratedName(name);
+                return generateNameCached(node, getTextOfNode);
+            }
+            else {
+                // Auto, Loop, and Unique names are cached based on their unique
+                // autoGenerateId.
+                const autoGenerateId = name.autoGenerateId;
+                return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = unescapeIdentifier(makeName(name)));
+            }
+        }
+
+        function generateNameCached(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            const nodeId = getNodeId(node);
+            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node, getTextOfNode)));
+        }
+
+        /**
+         * Returns a value indicating whether a name is unique globally, within the current file,
+         * or within the NameGenerator.
+         */
+        function isUniqueName(name: string): boolean {
+            return !(hasGlobalName && hasGlobalName(name))
+                && !currentSourceFile.identifiers.has(name)
+                && !generatedNames.has(name);
+        }
+
+        /**
+         * Returns a value indicating whether a name is unique within a container.
+         */
+        function isUniqueLocalName(name: string, container: Node): boolean {
+            for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
+                if (node.locals) {
+                    const local = node.locals.get(name);
+                    // We conservatively include alias symbols to cover cases where they're emitted as locals
+                    if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Return the next available name in the pattern _a ... _z, _0, _1, ...
+         * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.
+         * Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
+         */
+        function makeTempVariableName(flags: TempFlags): string {
+            if (flags && !(tempFlags & flags)) {
+                const name = flags === TempFlags._i ? "_i" : "_n";
+                if (isUniqueName(name)) {
+                    tempFlags |= flags;
+                    return name;
+                }
+            }
+            while (true) {
+                const count = tempFlags & TempFlags.CountMask;
+                tempFlags++;
+                // Skip over 'i' and 'n'
+                if (count !== 8 && count !== 13) {
+                    const name = count < 26
+                        ? "_" + String.fromCharCode(CharacterCodes.a + count)
+                        : "_" + (count - 26);
+                    if (isUniqueName(name)) {
+                        return name;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Generate a name that is unique within the current file and doesn't conflict with any names
+         * in global scope. The name is formed by adding an '_n' suffix to the specified base name,
+         * where n is a positive integer. Note that names generated by makeTempVariableName and
+         * makeUniqueName are guaranteed to never conflict.
+         */
+        function makeUniqueName(baseName: string): string {
+            // Find the first unique 'name_n', where n is a positive number
+            if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {
+                baseName += "_";
+            }
+            let i = 1;
+            while (true) {
+                const generatedName = baseName + i;
+                if (isUniqueName(generatedName)) {
+                    generatedNames.set(generatedName, generatedName);
+                    return generatedName;
+                }
+                i++;
+            }
+        }
+
+        /**
+         * Generates a unique name for a ModuleDeclaration or EnumDeclaration.
+         */
+        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            const name = getTextOfNode(node.name);
+            // Use module/enum name itself if it is unique, otherwise make a unique variation
+            return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
+        }
+
+        /**
+         * Generates a unique name for an ImportDeclaration or ExportDeclaration.
+         */
+        function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {
+            const expr = getExternalModuleName(node);
+            const baseName = expr.kind === SyntaxKind.StringLiteral ?
+                escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";
+            return makeUniqueName(baseName);
+        }
+
+        /**
+         * Generates a unique name for a default export.
+         */
+        function generateNameForExportDefault() {
+            return makeUniqueName("default");
+        }
+
+        /**
+         * Generates a unique name for a class expression.
+         */
+        function generateNameForClassExpression() {
+            return makeUniqueName("class");
+        }
+
+        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            if (isIdentifier(node.name)) {
+                return generateNameCached(node.name, getTextOfNode);
+            }
+            return makeTempVariableName(TempFlags.Auto);
+        }
+
+        /**
+         * Generates a unique name from a node.
+         */
+        function generateNameForNode(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string): string {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    return makeUniqueName(getTextOfNode(node));
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node, getTextOfNode);
+                case SyntaxKind.ImportDeclaration:
+                case SyntaxKind.ExportDeclaration:
+                    return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.ExportAssignment:
+                    return generateNameForExportDefault();
+                case SyntaxKind.ClassExpression:
+                    return generateNameForClassExpression();
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node, getTextOfNode);
+                default:
+                    return makeTempVariableName(TempFlags.Auto);
+            }
+        }
+
+        /**
+         * Generates a unique identifier for a node.
+         */
+        function makeName(name: GeneratedIdentifier) {
+            switch (name.autoGenerateKind) {
+                case GeneratedIdentifierKind.Auto:
+                    return makeTempVariableName(TempFlags.Auto);
+                case GeneratedIdentifierKind.Loop:
+                    return makeTempVariableName(TempFlags._i);
+                case GeneratedIdentifierKind.Unique:
+                    return makeUniqueName(name.text);
+            }
+
+            Debug.fail("Unsupported GeneratedIdentifierKind.");
+        }
+
+        /**
+         * Gets the node from which a name should be generated.
+         */
+        function getNodeForGeneratedName(name: GeneratedIdentifier) {
+            const autoGenerateId = name.autoGenerateId;
+            let node = name as Node;
+            let original = node.original;
+            while (original) {
+                node = original;
+
+                // if "node" is a different generated name (having a different
+                // "autoGenerateId"), use it and stop traversing.
+                if (isIdentifier(node)
+                    && node.autoGenerateKind === GeneratedIdentifierKind.Node
+                    && node.autoGenerateId !== autoGenerateId) {
+                    break;
+                }
+
+                original = node.original;
+            }
+
+            // otherwise, return the original node for the source;
+            return node;
+        }
+    }
+
+    function createDelimiterMap() {
+        const delimiters: string[] = [];
+        delimiters[ListFormat.None] = "";
+        delimiters[ListFormat.CommaDelimited] = ",";
+        delimiters[ListFormat.BarDelimited] = " |";
+        delimiters[ListFormat.AmpersandDelimited] = " &";
+        return delimiters;
+    }
+
+    function getDelimiter(format: ListFormat) {
+        return delimiters[format & ListFormat.DelimitersMask];
+    }
+
+    function createBracketsMap() {
+        const brackets: string[][] = [];
+        brackets[ListFormat.Braces] = ["{", "}"];
+        brackets[ListFormat.Parenthesis] = ["(", ")"];
+        brackets[ListFormat.AngleBrackets] = ["<", ">"];
+        brackets[ListFormat.SquareBrackets] = ["[", "]"];
+        return brackets;
+    }
+
+    function getOpeningBracket(format: ListFormat) {
+        return brackets[format & ListFormat.BracketsMask][0];
+    }
+
+    function getClosingBracket(format: ListFormat) {
+        return brackets[format & ListFormat.BracketsMask][1];
+    }
+
+    const enum ListFormat {
+        None = 0,
+
+        // Line separators
+        SingleLine = 0,                 // Prints the list on a single line (default).
+        MultiLine = 1 << 0,             // Prints the list on multiple lines.
+        PreserveLines = 1 << 1,         // Prints the list using line preservation if possible.
+        LinesMask = SingleLine | MultiLine | PreserveLines,
+
+        // Delimiters
+        NotDelimited = 0,               // There is no delimiter between list items (default).
+        BarDelimited = 1 << 2,          // Each list item is space-and-bar (" |") delimited.
+        AmpersandDelimited = 1 << 3,    // Each list item is space-and-ampersand (" &") delimited.
+        CommaDelimited = 1 << 4,        // Each list item is comma (",") delimited.
+        DelimitersMask = BarDelimited | AmpersandDelimited | CommaDelimited,
+
+        AllowTrailingComma = 1 << 5,    // Write a trailing comma (",") if present.
+
+        // Whitespace
+        Indented = 1 << 6,              // The list should be indented.
+        SpaceBetweenBraces = 1 << 7,    // Inserts a space after the opening brace and before the closing brace.
+        SpaceBetweenSiblings = 1 << 8,  // Inserts a space between each sibling node.
+
+        // Brackets/Braces
+        Braces = 1 << 9,                 // The list is surrounded by "{" and "}".
+        Parenthesis = 1 << 10,          // The list is surrounded by "(" and ")".
+        AngleBrackets = 1 << 11,        // The list is surrounded by "<" and ">".
+        SquareBrackets = 1 << 12,       // The list is surrounded by "[" and "]".
+        BracketsMask = Braces | Parenthesis | AngleBrackets | SquareBrackets,
+
+        OptionalIfUndefined = 1 << 13,  // Do not emit brackets if the list is undefined.
+        OptionalIfEmpty = 1 << 14,      // Do not emit brackets if the list is empty.
+        Optional = OptionalIfUndefined | OptionalIfEmpty,
+
+        // Other
+        PreferNewLine = 1 << 15,        // Prefer adding a LineTerminator between synthesized nodes.
+        NoTrailingNewLine = 1 << 16,    // Do not emit a trailing NewLine for a MultiLine list.
+        NoInterveningComments = 1 << 17, // Do not emit comments between each node
+
+        // Precomputed Formats
+        Modifiers = SingleLine | SpaceBetweenSiblings,
+        HeritageClauses = SingleLine | SpaceBetweenSiblings,
+        TypeLiteralMembers = MultiLine | Indented,
+        TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented,
+        UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine,
+        IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine,
+        ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings,
+        ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings,
+        ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces,
+        ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
+        CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
+        NewExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis | OptionalIfUndefined,
+        TemplateExpressionSpans = SingleLine | NoInterveningComments,
+        SingleLineBlockStatements = SpaceBetweenBraces | SpaceBetweenSiblings | SingleLine,
+        MultiLineBlockStatements = Indented | MultiLine,
+        VariableDeclarationList = CommaDelimited | SpaceBetweenSiblings | SingleLine,
+        SingleLineFunctionBodyStatements = SingleLine | SpaceBetweenSiblings | SpaceBetweenBraces,
+        MultiLineFunctionBodyStatements = MultiLine,
+        ClassHeritageClauses = SingleLine | SpaceBetweenSiblings,
+        ClassMembers = Indented | MultiLine,
+        InterfaceMembers = Indented | MultiLine,
+        EnumMembers = CommaDelimited | Indented | MultiLine,
+        CaseBlockClauses = Indented | MultiLine,
+        NamedImportsOrExportsElements = CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | SingleLine | SpaceBetweenBraces,
+        JsxElementChildren = SingleLine | NoInterveningComments,
+        JsxElementAttributes = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
+        CaseOrDefaultClauseStatements = Indented | MultiLine | NoTrailingNewLine | OptionalIfEmpty,
+        HeritageClauseTypes = CommaDelimited | SpaceBetweenSiblings | SingleLine,
+        SourceFileStatements = MultiLine | NoTrailingNewLine,
+        Decorators = MultiLine | Optional,
+        TypeArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
+        TypeParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
+        Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis,
+        IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
+    }
+}
\ No newline at end of file
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index 650b9b0ef02..d743f488e75 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -8,10 +8,9 @@ namespace ts {
          *
          * @param filePath The path to the generated output file.
          * @param sourceMapFilePath The path to the output source map file.
-         * @param sourceFiles The input source files for the program.
-         * @param isBundledEmit A value indicating whether the generated output file is a bundle.
+         * @param sourceFileOrBundle The input source file or bundle for the program.
          */
-        initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void;
+        initialize(filePath: string, sourceMapFilePath: string, sourceFileOrBundle: SourceFile | Bundle): void;
 
         /**
          * Reset the SourceMapWriter to an empty state.
@@ -38,11 +37,11 @@ namespace ts {
         /**
          * Emits a node with possible leading and trailing source maps.
          *
-         * @param emitContext The current emit context
+         * @param hint The current emit context
          * @param node The node to emit.
          * @param emitCallback The callback used to emit the node.
          */
-        emitNodeWithSourceMap(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+        emitNodeWithSourceMap(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
 
         /**
          * Emits a token of a node node with possible leading and trailing source maps.
@@ -115,10 +114,9 @@ namespace ts {
          *
          * @param filePath The path to the generated output file.
          * @param sourceMapFilePath The path to the output source map file.
-         * @param sourceFiles The input source files for the program.
-         * @param isBundledEmit A value indicating whether the generated output file is a bundle.
+         * @param sourceFileOrBundle The input source file or bundle for the program.
          */
-        function initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {
+        function initialize(filePath: string, sourceMapFilePath: string, sourceFileOrBundle: SourceFile | Bundle) {
             if (disabled) {
                 return;
             }
@@ -161,11 +159,10 @@ namespace ts {
 
             if (compilerOptions.mapRoot) {
                 sourceMapDir = normalizeSlashes(compilerOptions.mapRoot);
-                if (!isBundledEmit) { // emitting single module file
-                    Debug.assert(sourceFiles.length === 1);
+                if (sourceFileOrBundle.kind === SyntaxKind.SourceFile) { // emitting single module file
                     // For modules or multiple emit files the mapRoot will have directory structure like the sources
                     // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map
-                    sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFiles[0], host, sourceMapDir));
+                    sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFileOrBundle, host, sourceMapDir));
                 }
 
                 if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) {
@@ -311,12 +308,13 @@ namespace ts {
         /**
          * Emits a node with possible leading and trailing source maps.
          *
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emitCallback The callback used to emit the node.
          */
-        function emitNodeWithSourceMap(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function emitNodeWithSourceMap(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             if (disabled) {
-                return emitCallback(emitContext, node);
+                return emitCallback(hint, node);
             }
 
             if (node) {
@@ -332,11 +330,11 @@ namespace ts {
 
                 if (emitFlags & EmitFlags.NoNestedSourceMaps) {
                     disabled = true;
-                    emitCallback(emitContext, node);
+                    emitCallback(hint, node);
                     disabled = false;
                 }
                 else {
-                    emitCallback(emitContext, node);
+                    emitCallback(hint, node);
                 }
 
                 if (node.kind !== SyntaxKind.NotEmittedStatement
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index cef8c701455..62469df79c1 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -105,14 +105,16 @@ namespace ts {
             hoistFunctionDeclaration,
             requestEmitHelper,
             readEmitHelpers,
-            onSubstituteNode: (_emitContext, node) => node,
+            onSubstituteNode: (_, node) => node,
             enableSubstitution,
             isSubstitutionEnabled,
-            onEmitNode: (node, emitContext, emitCallback) => emitCallback(node, emitContext),
+            onEmitNode: (hint, node, callback) => callback(hint, node),
             enableEmitNotification,
             isEmitNotificationEnabled
         };
 
+        performance.mark("beforeTransform");
+
         // Chain together and initialize each transformer.
         const transformation = chain(...transformers)(context);
 
@@ -122,6 +124,9 @@ namespace ts {
         // Disable modification of the lexical environment.
         lexicalEnvironmentDisabled = true;
 
+        performance.mark("afterTransform");
+        performance.measure("transformTime", "beforeTransform", "afterTransform");
+
         return {
             transformed,
             emitNodeWithSubstitution,
@@ -159,21 +164,16 @@ namespace ts {
         /**
          * Emits a node with possible substitution.
          *
-         * @param emitContext The current emit context.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emitCallback The callback used to emit the node or its substitute.
          */
-        function emitNodeWithSubstitution(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function emitNodeWithSubstitution(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             if (node) {
                 if (isSubstitutionEnabled(node)) {
-                    const substitute = context.onSubstituteNode(emitContext, node);
-                    if (substitute && substitute !== node) {
-                        emitCallback(emitContext, substitute);
-                        return;
-                    }
+                    node = context.onSubstituteNode(hint, node) || node;
                 }
-
-                emitCallback(emitContext, node);
+                emitCallback(hint, node);
             }
         }
 
@@ -196,17 +196,17 @@ namespace ts {
         /**
          * Emits a node with possible emit notification.
          *
-         * @param emitContext The current emit context.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emitCallback The callback used to emit the node.
          */
-        function emitNodeWithNotification(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             if (node) {
                 if (isEmitNotificationEnabled(node)) {
-                    context.onEmitNode(emitContext, node, emitCallback);
+                    context.onEmitNode(hint, node, emitCallback);
                 }
                 else {
-                    emitCallback(emitContext, node);
+                    emitCallback(hint, node);
                 }
             }
         }
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index 3b8b4524aab..10ebe648fe2 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -3435,9 +3435,11 @@ namespace ts {
         /**
          * Called by the printer just before a node is printed.
          *
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to be printed.
+         * @param emitCallback The callback used to emit the node.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
             if (enabledSubstitutions & ES2015SubstitutionFlags.CapturedThis && isFunctionLike(node)) {
                 // If we are tracking a captured `this`, keep track of the enclosing function.
                 const ancestorFacts = enterSubtree(
@@ -3445,11 +3447,11 @@ namespace ts {
                     getEmitFlags(node) & EmitFlags.CapturesThis
                         ? HierarchyFacts.FunctionIncludes | HierarchyFacts.CapturesThis
                         : HierarchyFacts.FunctionIncludes);
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
                 exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);
                 return;
             }
-            previousOnEmitNode(emitContext, node, emitCallback);
+            previousOnEmitNode(hint, node, emitCallback);
         }
 
         /**
@@ -3484,13 +3486,13 @@ namespace ts {
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext The context for the emitter.
+         * @param hint The context for the emitter.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
 
-            if (emitContext === EmitContext.Expression) {
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(node);
             }
 
diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts
index c87dbe32518..a7f7b0da0ea 100644
--- a/src/compiler/transformers/es2017.ts
+++ b/src/compiler/transformers/es2017.ts
@@ -396,33 +396,33 @@ namespace ts {
         /**
          * Hook for node emit.
          *
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emit A callback used to emit the node in the printer.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
                 const savedCurrentSuperContainer = currentSuperContainer;
                 currentSuperContainer = node;
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
                 currentSuperContainer = savedCurrentSuperContainer;
             }
             else {
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
             }
         }
 
         /**
          * Hooks node substitutions.
          *
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
-         * @param isExpression A value indicating whether the node is to be used in an expression
-         *                     position.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
-            if (emitContext === EmitContext.Expression) {
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(<Expression>node);
             }
 
diff --git a/src/compiler/transformers/es5.ts b/src/compiler/transformers/es5.ts
index c3b011fe36d..8b030642a89 100644
--- a/src/compiler/transformers/es5.ts
+++ b/src/compiler/transformers/es5.ts
@@ -12,7 +12,7 @@ namespace ts {
         const compilerOptions = context.getCompilerOptions();
 
         // enable emit notification only if using --jsx preserve or react-native
-        let previousOnEmitNode: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
+        let previousOnEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
         let noSubstitution: boolean[];
         if (compilerOptions.jsx === JsxEmit.Preserve || compilerOptions.jsx === JsxEmit.ReactNative) {
             previousOnEmitNode = context.onEmitNode;
@@ -41,9 +41,11 @@ namespace ts {
         /**
          * Called by the printer just before a node is printed.
          *
-         * @param node The node to be printed.
+         * @param hint A hint as to the intended usage of the node.
+         * @param node The node to emit.
+         * @param emitCallback A callback used to emit the node.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (emitContext: EmitHint, node: Node) => void) {
             switch (node.kind) {
                 case SyntaxKind.JsxOpeningElement:
                 case SyntaxKind.JsxClosingElement:
@@ -53,21 +55,21 @@ namespace ts {
                     break;
             }
 
-            previousOnEmitNode(emitContext, node, emitCallback);
+            previousOnEmitNode(hint, node, emitCallback);
         }
 
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext The context for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
+        function onSubstituteNode(hint: EmitHint, node: Node) {
             if (node.id && noSubstitution && noSubstitution[node.id]) {
-                return previousOnSubstituteNode(emitContext, node);
+                return previousOnSubstituteNode(hint, node);
             }
 
-            node = previousOnSubstituteNode(emitContext, node);
+            node = previousOnSubstituteNode(hint, node);
             if (isPropertyAccessExpression(node)) {
                 return substitutePropertyAccessExpression(node);
             }
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 7dcfe76a427..ee17bdacbaf 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -1909,9 +1909,9 @@ namespace ts {
             return -1;
         }
 
-        function onSubstituteNode(emitContext: EmitContext, node: Node): Node {
-            node = previousOnSubstituteNode(emitContext, node);
-            if (emitContext === EmitContext.Expression) {
+        function onSubstituteNode(hint: EmitHint, node: Node): Node {
+            node = previousOnSubstituteNode(hint, node);
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(<Expression>node);
             }
             return node;
diff --git a/src/compiler/transformers/module/es2015.ts b/src/compiler/transformers/module/es2015.ts
index 5611f890164..86fa1295f7b 100644
--- a/src/compiler/transformers/module/es2015.ts
+++ b/src/compiler/transformers/module/es2015.ts
@@ -71,18 +71,18 @@ namespace ts {
         /**
          * Hook for node emit.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emit A callback used to emit the node in the printer.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
             if (isSourceFile(node)) {
                 currentSourceFile = node;
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
                 currentSourceFile = undefined;
             }
             else {
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
             }
         }
 
@@ -93,12 +93,12 @@ namespace ts {
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
-            if (isIdentifier(node) && emitContext === EmitContext.Expression) {
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
+            if (isIdentifier(node) && hint === EmitHint.Expression) {
                 return substituteExpressionIdentifier(node);
             }
             return node;
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index 0adea4fd540..e072429292a 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -1207,24 +1207,24 @@ namespace ts {
         /**
          * Hook for node emit notifications.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emit A callback used to emit the node in the printer.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
             if (node.kind === SyntaxKind.SourceFile) {
                 currentSourceFile = <SourceFile>node;
                 currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
                 noSubstitution = [];
 
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
 
                 currentSourceFile = undefined;
                 currentModuleInfo = undefined;
                 noSubstitution = undefined;
             }
             else {
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
             }
         }
 
@@ -1235,16 +1235,16 @@ namespace ts {
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
             if (node.id && noSubstitution[node.id]) {
                 return node;
             }
 
-            if (emitContext === EmitContext.Expression) {
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(<Expression>node);
             }
             else if (isShorthandPropertyAssignment(node)) {
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 3f1488b649d..6c59ea194cb 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -1548,11 +1548,11 @@ namespace ts {
         /**
          * Hook for node emit notifications.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
-         * @param emit A callback used to emit the node in the printer.
+         * @param emitCallback A callback used to emit the node in the printer.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
             if (node.kind === SyntaxKind.SourceFile) {
                 const id = getOriginalNodeId(node);
                 currentSourceFile = <SourceFile>node;
@@ -1564,7 +1564,7 @@ namespace ts {
                     delete noSubstitutionMap[id];
                 }
 
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
 
                 currentSourceFile = undefined;
                 moduleInfo = undefined;
@@ -1572,7 +1572,7 @@ namespace ts {
                 noSubstitution = undefined;
             }
             else {
-                previousOnEmitNode(emitContext, node, emitCallback);
+                previousOnEmitNode(hint, node, emitCallback);
             }
         }
 
@@ -1583,16 +1583,16 @@ namespace ts {
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
             if (isSubstitutionPrevented(node)) {
                 return node;
             }
 
-            if (emitContext === EmitContext.Expression) {
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(<Expression>node);
             }
 
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index e2b8b8fe2ec..a61998e8af9 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -3154,11 +3154,11 @@ namespace ts {
         /**
          * Hook for node emit.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emit A callback used to emit the node in the printer.
          */
-        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+        function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
             const savedApplicableSubstitutions = applicableSubstitutions;
 
             if (enabledSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && isTransformedModuleDeclaration(node)) {
@@ -3169,7 +3169,7 @@ namespace ts {
                 applicableSubstitutions |= TypeScriptSubstitutionFlags.NonQualifiedEnumMembers;
             }
 
-            previousOnEmitNode(emitContext, node, emitCallback);
+            previousOnEmitNode(hint, node, emitCallback);
 
             applicableSubstitutions = savedApplicableSubstitutions;
         }
@@ -3177,12 +3177,12 @@ namespace ts {
         /**
          * Hooks node substitutions.
          *
-         * @param emitContext A context hint for the emitter.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          */
-        function onSubstituteNode(emitContext: EmitContext, node: Node) {
-            node = previousOnSubstituteNode(emitContext, node);
-            if (emitContext === EmitContext.Expression) {
+        function onSubstituteNode(hint: EmitHint, node: Node) {
+            node = previousOnSubstituteNode(hint, node);
+            if (hint === EmitHint.Expression) {
                 return substituteExpression(<Expression>node);
             }
             else if (isShorthandPropertyAssignment(node)) {
diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index 52bb92ee1f0..54d5eb77e10 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -34,6 +34,7 @@
         "comments.ts",
         "sourcemap.ts",
         "declarationEmitter.ts",
+        "printer.ts",
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 8b49af402cf..682cd9e617b 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -348,6 +348,7 @@
         EnumMember,
         // Top-level nodes
         SourceFile,
+        Bundle,
 
         // JSDoc nodes
         JSDocTypeExpression,
@@ -557,15 +558,6 @@
 
     export type ModifiersArray = NodeArray<Modifier>;
 
-    /*@internal*/
-    export const enum GeneratedIdentifierKind {
-        None,   // Not automatically generated.
-        Auto,   // Automatically generated identifier.
-        Loop,   // Automatically generated identifier with a preference for '_i'.
-        Unique, // Unique name based on the 'text' property.
-        Node,   // Unique name based on the node in the 'original' property.
-    }
-
     export interface Identifier extends PrimaryExpression {
         kind: SyntaxKind.Identifier;
         text: string;                                  // Text of identifier (with escapes converted to characters)
@@ -580,7 +572,14 @@
         resolvedSymbol: Symbol;
     }
 
-    /*@internal*/
+    export const enum GeneratedIdentifierKind {
+        None,   // Not automatically generated.
+        Auto,   // Automatically generated identifier.
+        Loop,   // Automatically generated identifier with a preference for '_i'.
+        Unique, // Unique name based on the 'text' property.
+        Node,   // Unique name based on the node in the 'original' property.
+    }
+
     export interface GeneratedIdentifier extends Identifier {
         autoGenerateKind: GeneratedIdentifierKind.Auto
                         | GeneratedIdentifierKind.Loop
@@ -2201,6 +2200,11 @@
         /* @internal */ ambientModuleNames: string[];
     }
 
+    export interface Bundle extends Node {
+        kind: SyntaxKind.Bundle;
+        sourceFiles: SourceFile[];
+    }
+
     export interface ScriptReferenceHost {
         getCompilerOptions(): CompilerOptions;
         getSourceFile(fileName: string): SourceFile;
@@ -3780,8 +3784,7 @@
         LastEmitHelper = Generator
     }
 
-    /* @internal */
-    export const enum EmitContext {
+    export const enum EmitHint {
         SourceFile,         // Emitting a SourceFile
         Expression,         // Emitting an Expression
         IdentifierName,     // Emitting an IdentifierName
@@ -3856,7 +3859,7 @@
          * Hook used by transformers to substitute expressions just before they
          * are emitted by the pretty printer.
          */
-        onSubstituteNode?: (emitContext: EmitContext, node: Node) => Node;
+        onSubstituteNode?: (hint: EmitHint, node: Node) => Node;
 
         /**
          * Enables before/after emit notifications in the pretty printer for the provided
@@ -3874,7 +3877,7 @@
          * Hook used to allow transformers to capture state before or after
          * the printer emits a node.
          */
-        onEmitNode?: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
+        onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
     }
 
     /* @internal */
@@ -3887,25 +3890,61 @@
         /**
          * Emits the substitute for a node, if one is available; otherwise, emits the node.
          *
-         * @param emitContext The current emit context.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to substitute.
          * @param emitCallback A callback used to emit the node or its substitute.
          */
-        emitNodeWithSubstitution(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+        emitNodeWithSubstitution(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
 
         /**
          * Emits a node with possible notification.
          *
-         * @param emitContext The current emit context.
+         * @param hint A hint as to the intended usage of the node.
          * @param node The node to emit.
          * @param emitCallback A callback used to emit the node.
          */
-        emitNodeWithNotification(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+        emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
     }
 
     /* @internal */
     export type Transformer = (context: TransformationContext) => (node: SourceFile) => SourceFile;
 
+    export interface EmitTextWriter {
+        write(s: string): void;
+        writeTextOfNode(text: string, node: Node): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        getText(): string;
+        rawWrite(s: string): void;
+        writeLiteral(s: string): void;
+        getTextPos(): number;
+        getLine(): number;
+        getColumn(): number;
+        getIndent(): number;
+        isAtStartOfLine(): boolean;
+        reset(): void;
+    }
+
+    export interface Printer {
+        printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): void;
+        printFile(sourceFile: SourceFile): void;
+        printBundle(bundle: Bundle): void;
+    }
+
+    export interface PrinterOptions {
+        hasGlobalName?: (name: string) => boolean;
+        onEmitSourceMapOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        onEmitSourceMapOfToken?: (node: Node, token: SyntaxKind, pos: number, emitCallback: (token: SyntaxKind, pos: number) => number) => number;
+        onEmitCommentsOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        onEmitDetachedCommentsOfNode?: (node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) => void;
+        onEmitTrailingCommentsOfPosition?: (pos: number) => void;
+        onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        onEmitHelpers?: (node: Node, writeLines: (text: string) => void) => void;
+        onSetSourceFile?: (node: SourceFile) => void;
+        onSubstituteNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+    }
+
     export interface TextSpan {
         start: number;
         length: number;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 0a16875f8c0..5c92bfa65cc 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2088,16 +2088,19 @@ namespace ts {
         return undefined;
     }
 
-    export function getOriginalSourceFiles(sourceFiles: SourceFile[]) {
-        const originalSourceFiles: SourceFile[] = [];
-        for (const sourceFile of sourceFiles) {
-            const originalSourceFile = getParseTreeNode(sourceFile, isSourceFile);
-            if (originalSourceFile) {
-                originalSourceFiles.push(originalSourceFile);
-            }
+    export function getOriginalSourceFileOrBundle(sourceFileOrBundle: SourceFile | Bundle) {
+        if (sourceFileOrBundle.kind === SyntaxKind.Bundle) {
+            return updateBundle(sourceFileOrBundle, sameMap(sourceFileOrBundle.sourceFiles, getOriginalSourceFile));
         }
+        return getOriginalSourceFile(sourceFileOrBundle);
+    }
 
-        return originalSourceFiles;
+    function getOriginalSourceFile(sourceFile: SourceFile) {
+        return getParseTreeNode(sourceFile, isSourceFile) || sourceFile;
+    }
+
+    export function getOriginalSourceFiles(sourceFiles: SourceFile[]) {
+        return sameMap(sourceFiles, getOriginalSourceFile);
     }
 
     export function getOriginalNodeId(node: Node) {
@@ -2436,23 +2439,6 @@ namespace ts {
             s;
     }
 
-    export interface EmitTextWriter {
-        write(s: string): void;
-        writeTextOfNode(text: string, node: Node): void;
-        writeLine(): void;
-        increaseIndent(): void;
-        decreaseIndent(): void;
-        getText(): string;
-        rawWrite(s: string): void;
-        writeLiteral(s: string): void;
-        getTextPos(): number;
-        getLine(): number;
-        getColumn(): number;
-        getIndent(): number;
-        isAtStartOfLine(): boolean;
-        reset(): void;
-    }
-
     const indentStrings: string[] = ["", "    "];
     export function getIndentString(level: number) {
         if (indentStrings[level] === undefined) {
@@ -2635,7 +2621,7 @@ namespace ts {
      *   Else, calls `getSourceFilesToEmit` with the (optional) target source file to determine the list of source files to emit.
      */
     export function forEachEmittedFile(
-        host: EmitHost, action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean) => void,
+        host: EmitHost, action: (emitFileNames: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle, emitOnlyDtsFiles: boolean) => void,
         sourceFilesOrTargetSourceFile?: SourceFile[] | SourceFile,
         emitOnlyDtsFiles?: boolean) {
 
@@ -2646,7 +2632,7 @@ namespace ts {
                 const jsFilePath = options.outFile || options.out;
                 const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
                 const declarationFilePath = options.declaration ? removeFileExtension(jsFilePath) + ".d.ts" : undefined;
-                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, sourceFiles, /*isBundledEmit*/true, emitOnlyDtsFiles);
+                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, createBundle(sourceFiles), emitOnlyDtsFiles);
             }
         }
         else {
@@ -2654,7 +2640,7 @@ namespace ts {
                 const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, getOutputExtension(sourceFile, options));
                 const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
                 const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (emitOnlyDtsFiles || options.declaration) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;
-                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, [sourceFile], /*isBundledEmit*/false, emitOnlyDtsFiles);
+                action({ jsFilePath, sourceMapFilePath, declarationFilePath }, sourceFile, emitOnlyDtsFiles);
             }
         }
     }
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index ebd07118cc5..d7bb935db89 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -37,6 +37,7 @@
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
+        "../compiler/printer.ts",
         "../compiler/emitter.ts",
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index b60e00292f5..493f3b45f93 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -34,6 +34,7 @@
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
+        "../compiler/printer.ts",
         "../compiler/emitter.ts",
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",

From 56b1dcd8eaa3ce996867e0f586c768f6fa422cae Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 29 Jan 2017 12:39:15 -0800
Subject: [PATCH 127/159] Add tests

---
 .../classes/mixinClassesAnnotated.ts          | 67 +++++++++++++
 .../classes/mixinClassesAnonymous.ts          | 56 +++++++++++
 .../classes/mixinClassesMembers.ts            | 99 +++++++++++++++++++
 3 files changed, 222 insertions(+)
 create mode 100644 tests/cases/conformance/classes/mixinClassesAnnotated.ts
 create mode 100644 tests/cases/conformance/classes/mixinClassesAnonymous.ts
 create mode 100644 tests/cases/conformance/classes/mixinClassesMembers.ts

diff --git a/tests/cases/conformance/classes/mixinClassesAnnotated.ts b/tests/cases/conformance/classes/mixinClassesAnnotated.ts
new file mode 100644
index 00000000000..62f5e30c9a0
--- /dev/null
+++ b/tests/cases/conformance/classes/mixinClassesAnnotated.ts
@@ -0,0 +1,67 @@
+// @declaration: true
+
+type Constructor<T> = new(...args: any[]) => T;
+
+class Base {
+    constructor(public x: number, public y: number) {}
+}
+
+class Derived extends Base {
+    constructor(x: number, y: number, public z: number) {
+        super(x, y);
+    }
+}
+
+interface Printable {
+    print(): void;
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T): Constructor<Printable> & { message: string } & T =>
+    class extends superClass {
+        static message = "hello";
+        print() {
+            const output = this.x + "," + this.y;
+        }
+    }
+
+interface Tagged {
+    _tag: string;
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T): Constructor<Tagged> & T {
+    class C extends superClass {
+        _tag: string;
+        constructor(...args: any[]) {
+            super(...args);
+            this._tag = "hello";
+        }
+    }
+    return C;
+}
+
+const Thing1 = Tagged(Derived);
+const Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+
+function f1() {
+    const thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+
+function f2() {
+    const thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+
+class Thing3 extends Thing2 {
+    constructor(tag: string) {
+        super(10, 20, 30);
+        this._tag = tag;
+    }
+    test() {
+        this.print();
+    }
+}
diff --git a/tests/cases/conformance/classes/mixinClassesAnonymous.ts b/tests/cases/conformance/classes/mixinClassesAnonymous.ts
new file mode 100644
index 00000000000..24289b61e3e
--- /dev/null
+++ b/tests/cases/conformance/classes/mixinClassesAnonymous.ts
@@ -0,0 +1,56 @@
+type Constructor<T> = new(...args: any[]) => T;
+
+class Base {
+    constructor(public x: number, public y: number) {}
+}
+
+class Derived extends Base {
+    constructor(x: number, y: number, public z: number) {
+        super(x, y);
+    }
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T) => class extends superClass {
+    static message = "hello";
+    print() {
+        const output = this.x + "," + this.y;
+    }
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T) {
+    class C extends superClass {
+        _tag: string;
+        constructor(...args: any[]) {
+            super(...args);
+            this._tag = "hello";
+        }
+    }
+    return C;
+}
+
+const Thing1 = Tagged(Derived);
+const Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+
+function f1() {
+    const thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+
+function f2() {
+    const thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+
+class Thing3 extends Thing2 {
+    constructor(tag: string) {
+        super(10, 20, 30);
+        this._tag = tag;
+    }
+    test() {
+        this.print();
+    }
+}
diff --git a/tests/cases/conformance/classes/mixinClassesMembers.ts b/tests/cases/conformance/classes/mixinClassesMembers.ts
new file mode 100644
index 00000000000..905518c88f8
--- /dev/null
+++ b/tests/cases/conformance/classes/mixinClassesMembers.ts
@@ -0,0 +1,99 @@
+// @declaration: true
+
+declare class C1 {
+    public a: number;
+    protected b: number;
+    private c: number;
+    constructor(s: string);
+    constructor(n: number);
+}
+
+declare class M1 {
+    constructor(...args: any[]);
+    p: number;
+    static p: number;
+}
+
+declare class M2 {
+    constructor(...args: any[]);
+    f(): number;
+    static f(): number;
+}
+
+declare const Mixed1: typeof M1 & typeof C1;
+declare const Mixed2: typeof C1 & typeof M1;
+declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
+declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
+declare const Mixed5: typeof M1 & typeof M2;
+
+function f1() {
+    let x1 = new Mixed1("hello");
+    let x2 = new Mixed1(42);
+    let x3 = new Mixed2("hello");
+    let x4 = new Mixed2(42);
+    let x5 = new Mixed3("hello");
+    let x6 = new Mixed3(42);
+    let x7 = new Mixed4("hello");
+    let x8 = new Mixed4(42);
+    let x9 = new Mixed5();
+}
+
+function f2() {
+    let x = new Mixed1("hello");
+    x.a;
+    x.p;
+    Mixed1.p;
+}
+
+function f3() {
+    let x = new Mixed2("hello");
+    x.a;
+    x.p;
+    Mixed2.p;
+}
+
+function f4() {
+    let x = new Mixed3("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed3.p;
+    Mixed3.f();
+}
+
+function f5() {
+    let x = new Mixed4("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed4.p;
+    Mixed4.f();
+}
+
+function f6() {
+    let x = new Mixed5();
+    x.p;
+    x.f();
+    Mixed5.p;
+    Mixed5.f();
+}
+
+class C2 extends Mixed1 {
+    constructor() {
+        super("hello");
+        this.a;
+        this.b;
+        this.p;
+    }
+}
+
+class C3 extends Mixed3 {
+    constructor() {
+        super(42);
+        this.a;
+        this.b;
+        this.p;
+        this.f();
+    }
+    f() { return super.f(); }
+}

From 004dbf458c3f577140f2c4fbcab06f55ef9250d3 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 29 Jan 2017 12:39:33 -0800
Subject: [PATCH 128/159] Accept new baselines

---
 .../reference/mixinClassesAnnotated.js        | 183 +++++++++
 .../reference/mixinClassesAnnotated.symbols   | 193 ++++++++++
 .../reference/mixinClassesAnnotated.types     | 224 +++++++++++
 .../reference/mixinClassesAnonymous.js        | 140 +++++++
 .../reference/mixinClassesAnonymous.symbols   | 169 +++++++++
 .../reference/mixinClassesAnonymous.types     | 200 ++++++++++
 .../reference/mixinClassesMembers.js          | 220 +++++++++++
 .../reference/mixinClassesMembers.symbols     | 309 +++++++++++++++
 .../reference/mixinClassesMembers.types       | 352 ++++++++++++++++++
 9 files changed, 1990 insertions(+)
 create mode 100644 tests/baselines/reference/mixinClassesAnnotated.js
 create mode 100644 tests/baselines/reference/mixinClassesAnnotated.symbols
 create mode 100644 tests/baselines/reference/mixinClassesAnnotated.types
 create mode 100644 tests/baselines/reference/mixinClassesAnonymous.js
 create mode 100644 tests/baselines/reference/mixinClassesAnonymous.symbols
 create mode 100644 tests/baselines/reference/mixinClassesAnonymous.types
 create mode 100644 tests/baselines/reference/mixinClassesMembers.js
 create mode 100644 tests/baselines/reference/mixinClassesMembers.symbols
 create mode 100644 tests/baselines/reference/mixinClassesMembers.types

diff --git a/tests/baselines/reference/mixinClassesAnnotated.js b/tests/baselines/reference/mixinClassesAnnotated.js
new file mode 100644
index 00000000000..e3a781033ff
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnnotated.js
@@ -0,0 +1,183 @@
+//// [mixinClassesAnnotated.ts]
+
+type Constructor<T> = new(...args: any[]) => T;
+
+class Base {
+    constructor(public x: number, public y: number) {}
+}
+
+class Derived extends Base {
+    constructor(x: number, y: number, public z: number) {
+        super(x, y);
+    }
+}
+
+interface Printable {
+    print(): void;
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T): Constructor<Printable> & { message: string } & T =>
+    class extends superClass {
+        static message = "hello";
+        print() {
+            const output = this.x + "," + this.y;
+        }
+    }
+
+interface Tagged {
+    _tag: string;
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T): Constructor<Tagged> & T {
+    class C extends superClass {
+        _tag: string;
+        constructor(...args: any[]) {
+            super(...args);
+            this._tag = "hello";
+        }
+    }
+    return C;
+}
+
+const Thing1 = Tagged(Derived);
+const Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+
+function f1() {
+    const thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+
+function f2() {
+    const thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+
+class Thing3 extends Thing2 {
+    constructor(tag: string) {
+        super(10, 20, 30);
+        this._tag = tag;
+    }
+    test() {
+        this.print();
+    }
+}
+
+
+//// [mixinClassesAnnotated.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var Base = (function () {
+    function Base(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    return Base;
+}());
+var Derived = (function (_super) {
+    __extends(Derived, _super);
+    function Derived(x, y, z) {
+        var _this = _super.call(this, x, y) || this;
+        _this.z = z;
+        return _this;
+    }
+    return Derived;
+}(Base));
+var Printable = function (superClass) { return _a = (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.print = function () {
+            var output = this.x + "," + this.y;
+        };
+        return class_1;
+    }(superClass)),
+    _a.message = "hello",
+    _a; var _a; };
+function Tagged(superClass) {
+    var C = (function (_super) {
+        __extends(C, _super);
+        function C() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var _this = _super.apply(this, args) || this;
+            _this._tag = "hello";
+            return _this;
+        }
+        return C;
+    }(superClass));
+    return C;
+}
+var Thing1 = Tagged(Derived);
+var Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+function f1() {
+    var thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+function f2() {
+    var thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+var Thing3 = (function (_super) {
+    __extends(Thing3, _super);
+    function Thing3(tag) {
+        var _this = _super.call(this, 10, 20, 30) || this;
+        _this._tag = tag;
+        return _this;
+    }
+    Thing3.prototype.test = function () {
+        this.print();
+    };
+    return Thing3;
+}(Thing2));
+
+
+//// [mixinClassesAnnotated.d.ts]
+declare type Constructor<T> = new (...args: any[]) => T;
+declare class Base {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+}
+declare class Derived extends Base {
+    z: number;
+    constructor(x: number, y: number, z: number);
+}
+interface Printable {
+    print(): void;
+}
+declare const Printable: <T extends Constructor<Base>>(superClass: T) => Constructor<Printable> & {
+    message: string;
+} & T;
+interface Tagged {
+    _tag: string;
+}
+declare function Tagged<T extends Constructor<{}>>(superClass: T): Constructor<Tagged> & T;
+declare const Thing1: Constructor<Tagged> & typeof Derived;
+declare const Thing2: Constructor<Tagged> & Constructor<Printable> & {
+    message: string;
+} & typeof Derived;
+declare function f1(): void;
+declare function f2(): void;
+declare class Thing3 extends Thing2 {
+    constructor(tag: string);
+    test(): void;
+}
diff --git a/tests/baselines/reference/mixinClassesAnnotated.symbols b/tests/baselines/reference/mixinClassesAnnotated.symbols
new file mode 100644
index 00000000000..5a03789e2e6
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnnotated.symbols
@@ -0,0 +1,193 @@
+=== tests/cases/conformance/classes/mixinClassesAnnotated.ts ===
+
+type Constructor<T> = new(...args: any[]) => T;
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17))
+>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 1, 26))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 1, 17))
+
+class Base {
+>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47))
+
+    constructor(public x: number, public y: number) {}
+>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33))
+}
+
+class Derived extends Base {
+>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1))
+>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47))
+
+    constructor(x: number, y: number, public z: number) {
+>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16))
+>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26))
+>z : Symbol(Derived.z, Decl(mixinClassesAnnotated.ts, 8, 37))
+
+        super(x, y);
+>super : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47))
+>x : Symbol(x, Decl(mixinClassesAnnotated.ts, 8, 16))
+>y : Symbol(y, Decl(mixinClassesAnnotated.ts, 8, 26))
+    }
+}
+
+interface Printable {
+>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5))
+
+    print(): void;
+>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21))
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T): Constructor<Printable> & { message: string } & T =>
+>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0))
+>Base : Symbol(Base, Decl(mixinClassesAnnotated.ts, 1, 47))
+>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0))
+>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5))
+>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 17, 19))
+
+    class extends superClass {
+>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 17, 48))
+
+        static message = "hello";
+>message : Symbol((Anonymous class).message, Decl(mixinClassesAnnotated.ts, 18, 30))
+
+        print() {
+>print : Symbol((Anonymous class).print, Decl(mixinClassesAnnotated.ts, 19, 33))
+
+            const output = this.x + "," + this.y;
+>output : Symbol(output, Decl(mixinClassesAnnotated.ts, 21, 17))
+>this.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115))
+>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+>this.y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33))
+>this : Symbol((Anonymous class), Decl(mixinClassesAnnotated.ts, 17, 115))
+>y : Symbol(Base.y, Decl(mixinClassesAnnotated.ts, 4, 33))
+        }
+    }
+
+interface Tagged {
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1))
+
+    _tag: string;
+>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T): Constructor<Tagged> & T {
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0))
+>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnnotated.ts, 0, 0))
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1))
+>T : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16))
+
+    class C extends superClass {
+>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84))
+>superClass : Symbol(superClass, Decl(mixinClassesAnnotated.ts, 29, 43))
+
+        _tag: string;
+>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32))
+
+        constructor(...args: any[]) {
+>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20))
+
+            super(...args);
+>super : Symbol(T, Decl(mixinClassesAnnotated.ts, 29, 16))
+>args : Symbol(args, Decl(mixinClassesAnnotated.ts, 32, 20))
+
+            this._tag = "hello";
+>this._tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32))
+>this : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84))
+>_tag : Symbol(C._tag, Decl(mixinClassesAnnotated.ts, 30, 32))
+        }
+    }
+    return C;
+>C : Symbol(C, Decl(mixinClassesAnnotated.ts, 29, 84))
+}
+
+const Thing1 = Tagged(Derived);
+>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5))
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1))
+>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1))
+
+const Thing2 = Tagged(Printable(Derived));
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5))
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnnotated.ts, 23, 5), Decl(mixinClassesAnnotated.ts, 27, 1))
+>Printable : Symbol(Printable, Decl(mixinClassesAnnotated.ts, 11, 1), Decl(mixinClassesAnnotated.ts, 17, 5))
+>Derived : Symbol(Derived, Decl(mixinClassesAnnotated.ts, 5, 1))
+
+Thing2.message;
+>Thing2.message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5))
+>message : Symbol(message, Decl(mixinClassesAnnotated.ts, 17, 90))
+
+function f1() {
+>f1 : Symbol(f1, Decl(mixinClassesAnnotated.ts, 42, 15))
+
+    const thing = new Thing1(1, 2, 3);
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9))
+>Thing1 : Symbol(Thing1, Decl(mixinClassesAnnotated.ts, 40, 5))
+
+    thing.x;
+>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9))
+>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+
+    thing._tag;
+>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 45, 9))
+>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(mixinClassesAnnotated.ts, 48, 1))
+
+    const thing = new Thing2(1, 2, 3);
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5))
+
+    thing.x;
+>thing.x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9))
+>x : Symbol(Base.x, Decl(mixinClassesAnnotated.ts, 4, 16))
+
+    thing._tag;
+>thing._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9))
+>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+
+    thing.print();
+>thing.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21))
+>thing : Symbol(thing, Decl(mixinClassesAnnotated.ts, 51, 9))
+>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21))
+}
+
+class Thing3 extends Thing2 {
+>Thing3 : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnnotated.ts, 41, 5))
+
+    constructor(tag: string) {
+>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16))
+
+        super(10, 20, 30);
+        this._tag = tag;
+>this._tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1))
+>_tag : Symbol(Tagged._tag, Decl(mixinClassesAnnotated.ts, 25, 18))
+>tag : Symbol(tag, Decl(mixinClassesAnnotated.ts, 58, 16))
+    }
+    test() {
+>test : Symbol(Thing3.test, Decl(mixinClassesAnnotated.ts, 61, 5))
+
+        this.print();
+>this.print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21))
+>this : Symbol(Thing3, Decl(mixinClassesAnnotated.ts, 55, 1))
+>print : Symbol(Printable.print, Decl(mixinClassesAnnotated.ts, 13, 21))
+    }
+}
+
diff --git a/tests/baselines/reference/mixinClassesAnnotated.types b/tests/baselines/reference/mixinClassesAnnotated.types
new file mode 100644
index 00000000000..afaf4c4d25e
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnnotated.types
@@ -0,0 +1,224 @@
+=== tests/cases/conformance/classes/mixinClassesAnnotated.ts ===
+
+type Constructor<T> = new(...args: any[]) => T;
+>Constructor : Constructor<T>
+>T : T
+>args : any[]
+>T : T
+
+class Base {
+>Base : Base
+
+    constructor(public x: number, public y: number) {}
+>x : number
+>y : number
+}
+
+class Derived extends Base {
+>Derived : Derived
+>Base : Base
+
+    constructor(x: number, y: number, public z: number) {
+>x : number
+>y : number
+>z : number
+
+        super(x, y);
+>super(x, y) : void
+>super : typeof Base
+>x : number
+>y : number
+    }
+}
+
+interface Printable {
+>Printable : Printable
+
+    print(): void;
+>print : () => void
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T): Constructor<Printable> & { message: string } & T =>
+>Printable : <T extends Constructor<Base>>(superClass: T) => Constructor<Printable> & { message: string; } & T
+><T extends Constructor<Base>>(superClass: T): Constructor<Printable> & { message: string } & T =>    class extends superClass {        static message = "hello";        print() {            const output = this.x + "," + this.y;        }    } : <T extends Constructor<Base>>(superClass: T) => Constructor<Printable> & { message: string; } & T
+>T : T
+>Constructor : Constructor<T>
+>Base : Base
+>superClass : T
+>T : T
+>Constructor : Constructor<T>
+>Printable : Printable
+>message : string
+>T : T
+
+    class extends superClass {
+>class extends superClass {        static message = "hello";        print() {            const output = this.x + "," + this.y;        }    } : { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); message: string; } & T
+>superClass : Base
+
+        static message = "hello";
+>message : string
+>"hello" : "hello"
+
+        print() {
+>print : () => void
+
+            const output = this.x + "," + this.y;
+>output : string
+>this.x + "," + this.y : string
+>this.x + "," : string
+>this.x : number
+>this : this
+>x : number
+>"," : ","
+>this.y : number
+>this : this
+>y : number
+        }
+    }
+
+interface Tagged {
+>Tagged : Tagged
+
+    _tag: string;
+>_tag : string
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T): Constructor<Tagged> & T {
+>Tagged : <T extends Constructor<{}>>(superClass: T) => Constructor<Tagged> & T
+>T : T
+>Constructor : Constructor<T>
+>superClass : T
+>T : T
+>Constructor : Constructor<T>
+>Tagged : Tagged
+>T : T
+
+    class C extends superClass {
+>C : C
+>superClass : {}
+
+        _tag: string;
+>_tag : string
+
+        constructor(...args: any[]) {
+>args : any[]
+
+            super(...args);
+>super(...args) : void
+>super : T
+>...args : any
+>args : any[]
+
+            this._tag = "hello";
+>this._tag = "hello" : "hello"
+>this._tag : string
+>this : this
+>_tag : string
+>"hello" : "hello"
+        }
+    }
+    return C;
+>C : { new (...args: any[]): C; prototype: Tagged<any>.C; } & T
+}
+
+const Thing1 = Tagged(Derived);
+>Thing1 : Constructor<Tagged> & typeof Derived
+>Tagged(Derived) : Constructor<Tagged> & typeof Derived
+>Tagged : <T extends Constructor<{}>>(superClass: T) => Constructor<Tagged> & T
+>Derived : typeof Derived
+
+const Thing2 = Tagged(Printable(Derived));
+>Thing2 : Constructor<Tagged> & Constructor<Printable> & { message: string; } & typeof Derived
+>Tagged(Printable(Derived)) : Constructor<Tagged> & Constructor<Printable> & { message: string; } & typeof Derived
+>Tagged : <T extends Constructor<{}>>(superClass: T) => Constructor<Tagged> & T
+>Printable(Derived) : Constructor<Printable> & { message: string; } & typeof Derived
+>Printable : <T extends Constructor<Base>>(superClass: T) => Constructor<Printable> & { message: string; } & T
+>Derived : typeof Derived
+
+Thing2.message;
+>Thing2.message : string
+>Thing2 : Constructor<Tagged> & Constructor<Printable> & { message: string; } & typeof Derived
+>message : string
+
+function f1() {
+>f1 : () => void
+
+    const thing = new Thing1(1, 2, 3);
+>thing : Tagged & Derived
+>new Thing1(1, 2, 3) : Tagged & Derived
+>Thing1 : Constructor<Tagged> & typeof Derived
+>1 : 1
+>2 : 2
+>3 : 3
+
+    thing.x;
+>thing.x : number
+>thing : Tagged & Derived
+>x : number
+
+    thing._tag;
+>thing._tag : string
+>thing : Tagged & Derived
+>_tag : string
+}
+
+function f2() {
+>f2 : () => void
+
+    const thing = new Thing2(1, 2, 3);
+>thing : Tagged & Printable & Derived
+>new Thing2(1, 2, 3) : Tagged & Printable & Derived
+>Thing2 : Constructor<Tagged> & Constructor<Printable> & { message: string; } & typeof Derived
+>1 : 1
+>2 : 2
+>3 : 3
+
+    thing.x;
+>thing.x : number
+>thing : Tagged & Printable & Derived
+>x : number
+
+    thing._tag;
+>thing._tag : string
+>thing : Tagged & Printable & Derived
+>_tag : string
+
+    thing.print();
+>thing.print() : void
+>thing.print : () => void
+>thing : Tagged & Printable & Derived
+>print : () => void
+}
+
+class Thing3 extends Thing2 {
+>Thing3 : Thing3
+>Thing2 : Tagged & Printable & Derived
+
+    constructor(tag: string) {
+>tag : string
+
+        super(10, 20, 30);
+>super(10, 20, 30) : void
+>super : Constructor<Tagged> & Constructor<Printable> & { message: string; } & typeof Derived
+>10 : 10
+>20 : 20
+>30 : 30
+
+        this._tag = tag;
+>this._tag = tag : string
+>this._tag : string
+>this : this
+>_tag : string
+>tag : string
+    }
+    test() {
+>test : () => void
+
+        this.print();
+>this.print() : void
+>this.print : () => void
+>this : this
+>print : () => void
+    }
+}
+
diff --git a/tests/baselines/reference/mixinClassesAnonymous.js b/tests/baselines/reference/mixinClassesAnonymous.js
new file mode 100644
index 00000000000..c7b8ab5fd63
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnonymous.js
@@ -0,0 +1,140 @@
+//// [mixinClassesAnonymous.ts]
+type Constructor<T> = new(...args: any[]) => T;
+
+class Base {
+    constructor(public x: number, public y: number) {}
+}
+
+class Derived extends Base {
+    constructor(x: number, y: number, public z: number) {
+        super(x, y);
+    }
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T) => class extends superClass {
+    static message = "hello";
+    print() {
+        const output = this.x + "," + this.y;
+    }
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T) {
+    class C extends superClass {
+        _tag: string;
+        constructor(...args: any[]) {
+            super(...args);
+            this._tag = "hello";
+        }
+    }
+    return C;
+}
+
+const Thing1 = Tagged(Derived);
+const Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+
+function f1() {
+    const thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+
+function f2() {
+    const thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+
+class Thing3 extends Thing2 {
+    constructor(tag: string) {
+        super(10, 20, 30);
+        this._tag = tag;
+    }
+    test() {
+        this.print();
+    }
+}
+
+
+//// [mixinClassesAnonymous.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var Base = (function () {
+    function Base(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    return Base;
+}());
+var Derived = (function (_super) {
+    __extends(Derived, _super);
+    function Derived(x, y, z) {
+        var _this = _super.call(this, x, y) || this;
+        _this.z = z;
+        return _this;
+    }
+    return Derived;
+}(Base));
+var Printable = function (superClass) { return _a = (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.print = function () {
+            var output = this.x + "," + this.y;
+        };
+        return class_1;
+    }(superClass)),
+    _a.message = "hello",
+    _a; var _a; };
+function Tagged(superClass) {
+    var C = (function (_super) {
+        __extends(C, _super);
+        function C() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var _this = _super.apply(this, args) || this;
+            _this._tag = "hello";
+            return _this;
+        }
+        return C;
+    }(superClass));
+    return C;
+}
+var Thing1 = Tagged(Derived);
+var Thing2 = Tagged(Printable(Derived));
+Thing2.message;
+function f1() {
+    var thing = new Thing1(1, 2, 3);
+    thing.x;
+    thing._tag;
+}
+function f2() {
+    var thing = new Thing2(1, 2, 3);
+    thing.x;
+    thing._tag;
+    thing.print();
+}
+var Thing3 = (function (_super) {
+    __extends(Thing3, _super);
+    function Thing3(tag) {
+        var _this = _super.call(this, 10, 20, 30) || this;
+        _this._tag = tag;
+        return _this;
+    }
+    Thing3.prototype.test = function () {
+        this.print();
+    };
+    return Thing3;
+}(Thing2));
diff --git a/tests/baselines/reference/mixinClassesAnonymous.symbols b/tests/baselines/reference/mixinClassesAnonymous.symbols
new file mode 100644
index 00000000000..204d9c589fd
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnonymous.symbols
@@ -0,0 +1,169 @@
+=== tests/cases/conformance/classes/mixinClassesAnonymous.ts ===
+type Constructor<T> = new(...args: any[]) => T;
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnonymous.ts, 0, 0))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 0, 17))
+>args : Symbol(args, Decl(mixinClassesAnonymous.ts, 0, 26))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 0, 17))
+
+class Base {
+>Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 0, 47))
+
+    constructor(public x: number, public y: number) {}
+>x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+>y : Symbol(Base.y, Decl(mixinClassesAnonymous.ts, 3, 33))
+}
+
+class Derived extends Base {
+>Derived : Symbol(Derived, Decl(mixinClassesAnonymous.ts, 4, 1))
+>Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 0, 47))
+
+    constructor(x: number, y: number, public z: number) {
+>x : Symbol(x, Decl(mixinClassesAnonymous.ts, 7, 16))
+>y : Symbol(y, Decl(mixinClassesAnonymous.ts, 7, 26))
+>z : Symbol(Derived.z, Decl(mixinClassesAnonymous.ts, 7, 37))
+
+        super(x, y);
+>super : Symbol(Base, Decl(mixinClassesAnonymous.ts, 0, 47))
+>x : Symbol(x, Decl(mixinClassesAnonymous.ts, 7, 16))
+>y : Symbol(y, Decl(mixinClassesAnonymous.ts, 7, 26))
+    }
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T) => class extends superClass {
+>Printable : Symbol(Printable, Decl(mixinClassesAnonymous.ts, 12, 5))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 12, 19))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnonymous.ts, 0, 0))
+>Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 0, 47))
+>superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 12, 48))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 12, 19))
+>superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 12, 48))
+
+    static message = "hello";
+>message : Symbol((Anonymous class).message, Decl(mixinClassesAnonymous.ts, 12, 92))
+
+    print() {
+>print : Symbol((Anonymous class).print, Decl(mixinClassesAnonymous.ts, 13, 29))
+
+        const output = this.x + "," + this.y;
+>output : Symbol(output, Decl(mixinClassesAnonymous.ts, 15, 13))
+>this.x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+>this : Symbol((Anonymous class), Decl(mixinClassesAnonymous.ts, 12, 65))
+>x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+>this.y : Symbol(Base.y, Decl(mixinClassesAnonymous.ts, 3, 33))
+>this : Symbol((Anonymous class), Decl(mixinClassesAnonymous.ts, 12, 65))
+>y : Symbol(Base.y, Decl(mixinClassesAnonymous.ts, 3, 33))
+    }
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T) {
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnonymous.ts, 17, 1))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 19, 16))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnonymous.ts, 0, 0))
+>superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 19, 43))
+>T : Symbol(T, Decl(mixinClassesAnonymous.ts, 19, 16))
+
+    class C extends superClass {
+>C : Symbol(C, Decl(mixinClassesAnonymous.ts, 19, 59))
+>superClass : Symbol(superClass, Decl(mixinClassesAnonymous.ts, 19, 43))
+
+        _tag: string;
+>_tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+
+        constructor(...args: any[]) {
+>args : Symbol(args, Decl(mixinClassesAnonymous.ts, 22, 20))
+
+            super(...args);
+>super : Symbol(T, Decl(mixinClassesAnonymous.ts, 19, 16))
+>args : Symbol(args, Decl(mixinClassesAnonymous.ts, 22, 20))
+
+            this._tag = "hello";
+>this._tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+>this : Symbol(C, Decl(mixinClassesAnonymous.ts, 19, 59))
+>_tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+        }
+    }
+    return C;
+>C : Symbol(C, Decl(mixinClassesAnonymous.ts, 19, 59))
+}
+
+const Thing1 = Tagged(Derived);
+>Thing1 : Symbol(Thing1, Decl(mixinClassesAnonymous.ts, 30, 5))
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnonymous.ts, 17, 1))
+>Derived : Symbol(Derived, Decl(mixinClassesAnonymous.ts, 4, 1))
+
+const Thing2 = Tagged(Printable(Derived));
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnonymous.ts, 31, 5))
+>Tagged : Symbol(Tagged, Decl(mixinClassesAnonymous.ts, 17, 1))
+>Printable : Symbol(Printable, Decl(mixinClassesAnonymous.ts, 12, 5))
+>Derived : Symbol(Derived, Decl(mixinClassesAnonymous.ts, 4, 1))
+
+Thing2.message;
+>Thing2.message : Symbol((Anonymous class).message, Decl(mixinClassesAnonymous.ts, 12, 92))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnonymous.ts, 31, 5))
+>message : Symbol((Anonymous class).message, Decl(mixinClassesAnonymous.ts, 12, 92))
+
+function f1() {
+>f1 : Symbol(f1, Decl(mixinClassesAnonymous.ts, 32, 15))
+
+    const thing = new Thing1(1, 2, 3);
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 35, 9))
+>Thing1 : Symbol(Thing1, Decl(mixinClassesAnonymous.ts, 30, 5))
+
+    thing.x;
+>thing.x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 35, 9))
+>x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+
+    thing._tag;
+>thing._tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 35, 9))
+>_tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(mixinClassesAnonymous.ts, 38, 1))
+
+    const thing = new Thing2(1, 2, 3);
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 41, 9))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnonymous.ts, 31, 5))
+
+    thing.x;
+>thing.x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 41, 9))
+>x : Symbol(Base.x, Decl(mixinClassesAnonymous.ts, 3, 16))
+
+    thing._tag;
+>thing._tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 41, 9))
+>_tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+
+    thing.print();
+>thing.print : Symbol((Anonymous class).print, Decl(mixinClassesAnonymous.ts, 13, 29))
+>thing : Symbol(thing, Decl(mixinClassesAnonymous.ts, 41, 9))
+>print : Symbol((Anonymous class).print, Decl(mixinClassesAnonymous.ts, 13, 29))
+}
+
+class Thing3 extends Thing2 {
+>Thing3 : Symbol(Thing3, Decl(mixinClassesAnonymous.ts, 45, 1))
+>Thing2 : Symbol(Thing2, Decl(mixinClassesAnonymous.ts, 31, 5))
+
+    constructor(tag: string) {
+>tag : Symbol(tag, Decl(mixinClassesAnonymous.ts, 48, 16))
+
+        super(10, 20, 30);
+        this._tag = tag;
+>this._tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+>this : Symbol(Thing3, Decl(mixinClassesAnonymous.ts, 45, 1))
+>_tag : Symbol(C._tag, Decl(mixinClassesAnonymous.ts, 20, 32))
+>tag : Symbol(tag, Decl(mixinClassesAnonymous.ts, 48, 16))
+    }
+    test() {
+>test : Symbol(Thing3.test, Decl(mixinClassesAnonymous.ts, 51, 5))
+
+        this.print();
+>this.print : Symbol((Anonymous class).print, Decl(mixinClassesAnonymous.ts, 13, 29))
+>this : Symbol(Thing3, Decl(mixinClassesAnonymous.ts, 45, 1))
+>print : Symbol((Anonymous class).print, Decl(mixinClassesAnonymous.ts, 13, 29))
+    }
+}
+
diff --git a/tests/baselines/reference/mixinClassesAnonymous.types b/tests/baselines/reference/mixinClassesAnonymous.types
new file mode 100644
index 00000000000..54b1c2c3819
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesAnonymous.types
@@ -0,0 +1,200 @@
+=== tests/cases/conformance/classes/mixinClassesAnonymous.ts ===
+type Constructor<T> = new(...args: any[]) => T;
+>Constructor : Constructor<T>
+>T : T
+>args : any[]
+>T : T
+
+class Base {
+>Base : Base
+
+    constructor(public x: number, public y: number) {}
+>x : number
+>y : number
+}
+
+class Derived extends Base {
+>Derived : Derived
+>Base : Base
+
+    constructor(x: number, y: number, public z: number) {
+>x : number
+>y : number
+>z : number
+
+        super(x, y);
+>super(x, y) : void
+>super : typeof Base
+>x : number
+>y : number
+    }
+}
+
+const Printable = <T extends Constructor<Base>>(superClass: T) => class extends superClass {
+>Printable : <T extends Constructor<Base>>(superClass: T) => { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); message: string; } & T
+><T extends Constructor<Base>>(superClass: T) => class extends superClass {    static message = "hello";    print() {        const output = this.x + "," + this.y;    }} : <T extends Constructor<Base>>(superClass: T) => { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); message: string; } & T
+>T : T
+>Constructor : Constructor<T>
+>Base : Base
+>superClass : T
+>T : T
+>class extends superClass {    static message = "hello";    print() {        const output = this.x + "," + this.y;    }} : { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); message: string; } & T
+>superClass : Base
+
+    static message = "hello";
+>message : string
+>"hello" : "hello"
+
+    print() {
+>print : () => void
+
+        const output = this.x + "," + this.y;
+>output : string
+>this.x + "," + this.y : string
+>this.x + "," : string
+>this.x : number
+>this : this
+>x : number
+>"," : ","
+>this.y : number
+>this : this
+>y : number
+    }
+}
+
+function Tagged<T extends Constructor<{}>>(superClass: T) {
+>Tagged : <T extends Constructor<{}>>(superClass: T) => { new (...args: any[]): C; prototype: Tagged<any>.C; } & T
+>T : T
+>Constructor : Constructor<T>
+>superClass : T
+>T : T
+
+    class C extends superClass {
+>C : C
+>superClass : {}
+
+        _tag: string;
+>_tag : string
+
+        constructor(...args: any[]) {
+>args : any[]
+
+            super(...args);
+>super(...args) : void
+>super : T
+>...args : any
+>args : any[]
+
+            this._tag = "hello";
+>this._tag = "hello" : "hello"
+>this._tag : string
+>this : this
+>_tag : string
+>"hello" : "hello"
+        }
+    }
+    return C;
+>C : { new (...args: any[]): C; prototype: Tagged<any>.C; } & T
+}
+
+const Thing1 = Tagged(Derived);
+>Thing1 : { new (...args: any[]): Tagged<typeof Derived>.C; prototype: Tagged<any>.C; } & typeof Derived
+>Tagged(Derived) : { new (...args: any[]): Tagged<typeof Derived>.C; prototype: Tagged<any>.C; } & typeof Derived
+>Tagged : <T extends Constructor<{}>>(superClass: T) => { new (...args: any[]): C; prototype: Tagged<any>.C; } & T
+>Derived : typeof Derived
+
+const Thing2 = Tagged(Printable(Derived));
+>Thing2 : { new (...args: any[]): Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C; prototype: Tagged<any>.C; } & { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>Tagged(Printable(Derived)) : { new (...args: any[]): Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C; prototype: Tagged<any>.C; } & { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>Tagged : <T extends Constructor<{}>>(superClass: T) => { new (...args: any[]): C; prototype: Tagged<any>.C; } & T
+>Printable(Derived) : { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>Printable : <T extends Constructor<Base>>(superClass: T) => { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); message: string; } & T
+>Derived : typeof Derived
+
+Thing2.message;
+>Thing2.message : string
+>Thing2 : { new (...args: any[]): Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C; prototype: Tagged<any>.C; } & { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>message : string
+
+function f1() {
+>f1 : () => void
+
+    const thing = new Thing1(1, 2, 3);
+>thing : Tagged<typeof Derived>.C & Derived
+>new Thing1(1, 2, 3) : Tagged<typeof Derived>.C & Derived
+>Thing1 : { new (...args: any[]): Tagged<typeof Derived>.C; prototype: Tagged<any>.C; } & typeof Derived
+>1 : 1
+>2 : 2
+>3 : 3
+
+    thing.x;
+>thing.x : number
+>thing : Tagged<typeof Derived>.C & Derived
+>x : number
+
+    thing._tag;
+>thing._tag : string
+>thing : Tagged<typeof Derived>.C & Derived
+>_tag : string
+}
+
+function f2() {
+>f2 : () => void
+
+    const thing = new Thing2(1, 2, 3);
+>thing : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+>new Thing2(1, 2, 3) : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+>Thing2 : { new (...args: any[]): Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C; prototype: Tagged<any>.C; } & { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>1 : 1
+>2 : 2
+>3 : 3
+
+    thing.x;
+>thing.x : number
+>thing : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+>x : number
+
+    thing._tag;
+>thing._tag : string
+>thing : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+>_tag : string
+
+    thing.print();
+>thing.print() : void
+>thing.print : () => void
+>thing : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+>print : () => void
+}
+
+class Thing3 extends Thing2 {
+>Thing3 : Thing3
+>Thing2 : Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C & <typeof Derived>.(Anonymous class) & Derived
+
+    constructor(tag: string) {
+>tag : string
+
+        super(10, 20, 30);
+>super(10, 20, 30) : void
+>super : { new (...args: any[]): Tagged<{ new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived>.C; prototype: Tagged<any>.C; } & { new (...args: any[]): <typeof Derived>.(Anonymous class); prototype: <any>.(Anonymous class); message: string; } & typeof Derived
+>10 : 10
+>20 : 20
+>30 : 30
+
+        this._tag = tag;
+>this._tag = tag : string
+>this._tag : string
+>this : this
+>_tag : string
+>tag : string
+    }
+    test() {
+>test : () => void
+
+        this.print();
+>this.print() : void
+>this.print : () => void
+>this : this
+>print : () => void
+    }
+}
+
diff --git a/tests/baselines/reference/mixinClassesMembers.js b/tests/baselines/reference/mixinClassesMembers.js
new file mode 100644
index 00000000000..01fc1bb0032
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesMembers.js
@@ -0,0 +1,220 @@
+//// [mixinClassesMembers.ts]
+
+declare class C1 {
+    public a: number;
+    protected b: number;
+    private c: number;
+    constructor(s: string);
+    constructor(n: number);
+}
+
+declare class M1 {
+    constructor(...args: any[]);
+    p: number;
+    static p: number;
+}
+
+declare class M2 {
+    constructor(...args: any[]);
+    f(): number;
+    static f(): number;
+}
+
+declare const Mixed1: typeof M1 & typeof C1;
+declare const Mixed2: typeof C1 & typeof M1;
+declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
+declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
+declare const Mixed5: typeof M1 & typeof M2;
+
+function f1() {
+    let x1 = new Mixed1("hello");
+    let x2 = new Mixed1(42);
+    let x3 = new Mixed2("hello");
+    let x4 = new Mixed2(42);
+    let x5 = new Mixed3("hello");
+    let x6 = new Mixed3(42);
+    let x7 = new Mixed4("hello");
+    let x8 = new Mixed4(42);
+    let x9 = new Mixed5();
+}
+
+function f2() {
+    let x = new Mixed1("hello");
+    x.a;
+    x.p;
+    Mixed1.p;
+}
+
+function f3() {
+    let x = new Mixed2("hello");
+    x.a;
+    x.p;
+    Mixed2.p;
+}
+
+function f4() {
+    let x = new Mixed3("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed3.p;
+    Mixed3.f();
+}
+
+function f5() {
+    let x = new Mixed4("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed4.p;
+    Mixed4.f();
+}
+
+function f6() {
+    let x = new Mixed5();
+    x.p;
+    x.f();
+    Mixed5.p;
+    Mixed5.f();
+}
+
+class C2 extends Mixed1 {
+    constructor() {
+        super("hello");
+        this.a;
+        this.b;
+        this.p;
+    }
+}
+
+class C3 extends Mixed3 {
+    constructor() {
+        super(42);
+        this.a;
+        this.b;
+        this.p;
+        this.f();
+    }
+    f() { return super.f(); }
+}
+
+
+//// [mixinClassesMembers.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+function f1() {
+    var x1 = new Mixed1("hello");
+    var x2 = new Mixed1(42);
+    var x3 = new Mixed2("hello");
+    var x4 = new Mixed2(42);
+    var x5 = new Mixed3("hello");
+    var x6 = new Mixed3(42);
+    var x7 = new Mixed4("hello");
+    var x8 = new Mixed4(42);
+    var x9 = new Mixed5();
+}
+function f2() {
+    var x = new Mixed1("hello");
+    x.a;
+    x.p;
+    Mixed1.p;
+}
+function f3() {
+    var x = new Mixed2("hello");
+    x.a;
+    x.p;
+    Mixed2.p;
+}
+function f4() {
+    var x = new Mixed3("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed3.p;
+    Mixed3.f();
+}
+function f5() {
+    var x = new Mixed4("hello");
+    x.a;
+    x.p;
+    x.f();
+    Mixed4.p;
+    Mixed4.f();
+}
+function f6() {
+    var x = new Mixed5();
+    x.p;
+    x.f();
+    Mixed5.p;
+    Mixed5.f();
+}
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        var _this = _super.call(this, "hello") || this;
+        _this.a;
+        _this.b;
+        _this.p;
+        return _this;
+    }
+    return C2;
+}(Mixed1));
+var C3 = (function (_super) {
+    __extends(C3, _super);
+    function C3() {
+        var _this = _super.call(this, 42) || this;
+        _this.a;
+        _this.b;
+        _this.p;
+        _this.f();
+        return _this;
+    }
+    C3.prototype.f = function () { return _super.prototype.f.call(this); };
+    return C3;
+}(Mixed3));
+
+
+//// [mixinClassesMembers.d.ts]
+declare class C1 {
+    a: number;
+    protected b: number;
+    private c;
+    constructor(s: string);
+    constructor(n: number);
+}
+declare class M1 {
+    constructor(...args: any[]);
+    p: number;
+    static p: number;
+}
+declare class M2 {
+    constructor(...args: any[]);
+    f(): number;
+    static f(): number;
+}
+declare const Mixed1: typeof M1 & typeof C1;
+declare const Mixed2: typeof C1 & typeof M1;
+declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
+declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
+declare const Mixed5: typeof M1 & typeof M2;
+declare function f1(): void;
+declare function f2(): void;
+declare function f3(): void;
+declare function f4(): void;
+declare function f5(): void;
+declare function f6(): void;
+declare class C2 extends Mixed1 {
+    constructor();
+}
+declare class C3 extends Mixed3 {
+    constructor();
+    f(): number;
+}
diff --git a/tests/baselines/reference/mixinClassesMembers.symbols b/tests/baselines/reference/mixinClassesMembers.symbols
new file mode 100644
index 00000000000..fabfe7e6d86
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesMembers.symbols
@@ -0,0 +1,309 @@
+=== tests/cases/conformance/classes/mixinClassesMembers.ts ===
+
+declare class C1 {
+>C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0))
+
+    public a: number;
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+    protected b: number;
+>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21))
+
+    private c: number;
+>c : Symbol(C1.c, Decl(mixinClassesMembers.ts, 3, 24))
+
+    constructor(s: string);
+>s : Symbol(s, Decl(mixinClassesMembers.ts, 5, 16))
+
+    constructor(n: number);
+>n : Symbol(n, Decl(mixinClassesMembers.ts, 6, 16))
+}
+
+declare class M1 {
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+
+    constructor(...args: any[]);
+>args : Symbol(args, Decl(mixinClassesMembers.ts, 10, 16))
+
+    p: number;
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    static p: number;
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+}
+
+declare class M2 {
+>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1))
+
+    constructor(...args: any[]);
+>args : Symbol(args, Decl(mixinClassesMembers.ts, 16, 16))
+
+    f(): number;
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+
+    static f(): number;
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+}
+
+declare const Mixed1: typeof M1 & typeof C1;
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+>C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0))
+
+declare const Mixed2: typeof C1 & typeof M1;
+>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13))
+>C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0))
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+
+declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1))
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+>C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0))
+
+declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+>C1 : Symbol(C1, Decl(mixinClassesMembers.ts, 0, 0))
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1))
+
+declare const Mixed5: typeof M1 & typeof M2;
+>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13))
+>M1 : Symbol(M1, Decl(mixinClassesMembers.ts, 7, 1))
+>M2 : Symbol(M2, Decl(mixinClassesMembers.ts, 13, 1))
+
+function f1() {
+>f1 : Symbol(f1, Decl(mixinClassesMembers.ts, 25, 44))
+
+    let x1 = new Mixed1("hello");
+>x1 : Symbol(x1, Decl(mixinClassesMembers.ts, 28, 7))
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+
+    let x2 = new Mixed1(42);
+>x2 : Symbol(x2, Decl(mixinClassesMembers.ts, 29, 7))
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+
+    let x3 = new Mixed2("hello");
+>x3 : Symbol(x3, Decl(mixinClassesMembers.ts, 30, 7))
+>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13))
+
+    let x4 = new Mixed2(42);
+>x4 : Symbol(x4, Decl(mixinClassesMembers.ts, 31, 7))
+>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13))
+
+    let x5 = new Mixed3("hello");
+>x5 : Symbol(x5, Decl(mixinClassesMembers.ts, 32, 7))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+
+    let x6 = new Mixed3(42);
+>x6 : Symbol(x6, Decl(mixinClassesMembers.ts, 33, 7))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+
+    let x7 = new Mixed4("hello");
+>x7 : Symbol(x7, Decl(mixinClassesMembers.ts, 34, 7))
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+
+    let x8 = new Mixed4(42);
+>x8 : Symbol(x8, Decl(mixinClassesMembers.ts, 35, 7))
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+
+    let x9 = new Mixed5();
+>x9 : Symbol(x9, Decl(mixinClassesMembers.ts, 36, 7))
+>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(mixinClassesMembers.ts, 37, 1))
+
+    let x = new Mixed1("hello");
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7))
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+
+    x.a;
+>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+    x.p;
+>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 40, 7))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    Mixed1.p;
+>Mixed1.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+}
+
+function f3() {
+>f3 : Symbol(f3, Decl(mixinClassesMembers.ts, 44, 1))
+
+    let x = new Mixed2("hello");
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7))
+>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13))
+
+    x.a;
+>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+    x.p;
+>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 47, 7))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    Mixed2.p;
+>Mixed2.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+>Mixed2 : Symbol(Mixed2, Decl(mixinClassesMembers.ts, 22, 13))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+}
+
+function f4() {
+>f4 : Symbol(f4, Decl(mixinClassesMembers.ts, 51, 1))
+
+    let x = new Mixed3("hello");
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+
+    x.a;
+>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+    x.p;
+>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    x.f();
+>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 54, 7))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+
+    Mixed3.p;
+>Mixed3.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+
+    Mixed3.f();
+>Mixed3.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+}
+
+function f5() {
+>f5 : Symbol(f5, Decl(mixinClassesMembers.ts, 60, 1))
+
+    let x = new Mixed4("hello");
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7))
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+
+    x.a;
+>x.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+    x.p;
+>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    x.f();
+>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 63, 7))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+
+    Mixed4.p;
+>Mixed4.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+
+    Mixed4.f();
+>Mixed4.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+>Mixed4 : Symbol(Mixed4, Decl(mixinClassesMembers.ts, 24, 13))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+}
+
+function f6() {
+>f6 : Symbol(f6, Decl(mixinClassesMembers.ts, 69, 1))
+
+    let x = new Mixed5();
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7))
+>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13))
+
+    x.p;
+>x.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+    x.f();
+>x.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+>x : Symbol(x, Decl(mixinClassesMembers.ts, 72, 7))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+
+    Mixed5.p;
+>Mixed5.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 11, 14))
+
+    Mixed5.f();
+>Mixed5.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+>Mixed5 : Symbol(Mixed5, Decl(mixinClassesMembers.ts, 25, 13))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 17, 16))
+}
+
+class C2 extends Mixed1 {
+>C2 : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1))
+>Mixed1 : Symbol(Mixed1, Decl(mixinClassesMembers.ts, 21, 13))
+
+    constructor() {
+        super("hello");
+        this.a;
+>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+        this.b;
+>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21))
+>this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1))
+>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21))
+
+        this.p;
+>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>this : Symbol(C2, Decl(mixinClassesMembers.ts, 77, 1))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+    }
+}
+
+class C3 extends Mixed3 {
+>C3 : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1))
+>Mixed3 : Symbol(Mixed3, Decl(mixinClassesMembers.ts, 23, 13))
+
+    constructor() {
+        super(42);
+        this.a;
+>this.a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+>this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1))
+>a : Symbol(C1.a, Decl(mixinClassesMembers.ts, 1, 18))
+
+        this.b;
+>this.b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21))
+>this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1))
+>b : Symbol(C1.b, Decl(mixinClassesMembers.ts, 2, 21))
+
+        this.p;
+>this.p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+>this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1))
+>p : Symbol(M1.p, Decl(mixinClassesMembers.ts, 10, 32))
+
+        this.f();
+>this.f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5))
+>this : Symbol(C3, Decl(mixinClassesMembers.ts, 86, 1))
+>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5))
+    }
+    f() { return super.f(); }
+>f : Symbol(C3.f, Decl(mixinClassesMembers.ts, 95, 5))
+>super.f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+>f : Symbol(M2.f, Decl(mixinClassesMembers.ts, 16, 32))
+}
+
diff --git a/tests/baselines/reference/mixinClassesMembers.types b/tests/baselines/reference/mixinClassesMembers.types
new file mode 100644
index 00000000000..c8b29175415
--- /dev/null
+++ b/tests/baselines/reference/mixinClassesMembers.types
@@ -0,0 +1,352 @@
+=== tests/cases/conformance/classes/mixinClassesMembers.ts ===
+
+declare class C1 {
+>C1 : C1
+
+    public a: number;
+>a : number
+
+    protected b: number;
+>b : number
+
+    private c: number;
+>c : number
+
+    constructor(s: string);
+>s : string
+
+    constructor(n: number);
+>n : number
+}
+
+declare class M1 {
+>M1 : M1
+
+    constructor(...args: any[]);
+>args : any[]
+
+    p: number;
+>p : number
+
+    static p: number;
+>p : number
+}
+
+declare class M2 {
+>M2 : M2
+
+    constructor(...args: any[]);
+>args : any[]
+
+    f(): number;
+>f : () => number
+
+    static f(): number;
+>f : () => number
+}
+
+declare const Mixed1: typeof M1 & typeof C1;
+>Mixed1 : typeof M1 & typeof C1
+>M1 : typeof M1
+>C1 : typeof C1
+
+declare const Mixed2: typeof C1 & typeof M1;
+>Mixed2 : typeof C1 & typeof M1
+>C1 : typeof C1
+>M1 : typeof M1
+
+declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>M2 : typeof M2
+>M1 : typeof M1
+>C1 : typeof C1
+
+declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>C1 : typeof C1
+>M1 : typeof M1
+>M2 : typeof M2
+
+declare const Mixed5: typeof M1 & typeof M2;
+>Mixed5 : typeof M1 & typeof M2
+>M1 : typeof M1
+>M2 : typeof M2
+
+function f1() {
+>f1 : () => void
+
+    let x1 = new Mixed1("hello");
+>x1 : M1 & C1
+>new Mixed1("hello") : M1 & C1
+>Mixed1 : typeof M1 & typeof C1
+>"hello" : "hello"
+
+    let x2 = new Mixed1(42);
+>x2 : M1 & C1
+>new Mixed1(42) : M1 & C1
+>Mixed1 : typeof M1 & typeof C1
+>42 : 42
+
+    let x3 = new Mixed2("hello");
+>x3 : C1 & M1
+>new Mixed2("hello") : C1 & M1
+>Mixed2 : typeof C1 & typeof M1
+>"hello" : "hello"
+
+    let x4 = new Mixed2(42);
+>x4 : C1 & M1
+>new Mixed2(42) : C1 & M1
+>Mixed2 : typeof C1 & typeof M1
+>42 : 42
+
+    let x5 = new Mixed3("hello");
+>x5 : M2 & M1 & C1
+>new Mixed3("hello") : M2 & M1 & C1
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>"hello" : "hello"
+
+    let x6 = new Mixed3(42);
+>x6 : M2 & M1 & C1
+>new Mixed3(42) : M2 & M1 & C1
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>42 : 42
+
+    let x7 = new Mixed4("hello");
+>x7 : C1 & M1 & M2
+>new Mixed4("hello") : C1 & M1 & M2
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>"hello" : "hello"
+
+    let x8 = new Mixed4(42);
+>x8 : C1 & M1 & M2
+>new Mixed4(42) : C1 & M1 & M2
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>42 : 42
+
+    let x9 = new Mixed5();
+>x9 : M1 & M2
+>new Mixed5() : M1 & M2
+>Mixed5 : typeof M1 & typeof M2
+}
+
+function f2() {
+>f2 : () => void
+
+    let x = new Mixed1("hello");
+>x : M1 & C1
+>new Mixed1("hello") : M1 & C1
+>Mixed1 : typeof M1 & typeof C1
+>"hello" : "hello"
+
+    x.a;
+>x.a : number
+>x : M1 & C1
+>a : number
+
+    x.p;
+>x.p : number
+>x : M1 & C1
+>p : number
+
+    Mixed1.p;
+>Mixed1.p : number
+>Mixed1 : typeof M1 & typeof C1
+>p : number
+}
+
+function f3() {
+>f3 : () => void
+
+    let x = new Mixed2("hello");
+>x : C1 & M1
+>new Mixed2("hello") : C1 & M1
+>Mixed2 : typeof C1 & typeof M1
+>"hello" : "hello"
+
+    x.a;
+>x.a : number
+>x : C1 & M1
+>a : number
+
+    x.p;
+>x.p : number
+>x : C1 & M1
+>p : number
+
+    Mixed2.p;
+>Mixed2.p : number
+>Mixed2 : typeof C1 & typeof M1
+>p : number
+}
+
+function f4() {
+>f4 : () => void
+
+    let x = new Mixed3("hello");
+>x : M2 & M1 & C1
+>new Mixed3("hello") : M2 & M1 & C1
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>"hello" : "hello"
+
+    x.a;
+>x.a : number
+>x : M2 & M1 & C1
+>a : number
+
+    x.p;
+>x.p : number
+>x : M2 & M1 & C1
+>p : number
+
+    x.f();
+>x.f() : number
+>x.f : () => number
+>x : M2 & M1 & C1
+>f : () => number
+
+    Mixed3.p;
+>Mixed3.p : number
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>p : number
+
+    Mixed3.f();
+>Mixed3.f() : number
+>Mixed3.f : () => number
+>Mixed3 : typeof M2 & typeof M1 & typeof C1
+>f : () => number
+}
+
+function f5() {
+>f5 : () => void
+
+    let x = new Mixed4("hello");
+>x : C1 & M1 & M2
+>new Mixed4("hello") : C1 & M1 & M2
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>"hello" : "hello"
+
+    x.a;
+>x.a : number
+>x : C1 & M1 & M2
+>a : number
+
+    x.p;
+>x.p : number
+>x : C1 & M1 & M2
+>p : number
+
+    x.f();
+>x.f() : number
+>x.f : () => number
+>x : C1 & M1 & M2
+>f : () => number
+
+    Mixed4.p;
+>Mixed4.p : number
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>p : number
+
+    Mixed4.f();
+>Mixed4.f() : number
+>Mixed4.f : () => number
+>Mixed4 : typeof C1 & typeof M1 & typeof M2
+>f : () => number
+}
+
+function f6() {
+>f6 : () => void
+
+    let x = new Mixed5();
+>x : M1 & M2
+>new Mixed5() : M1 & M2
+>Mixed5 : typeof M1 & typeof M2
+
+    x.p;
+>x.p : number
+>x : M1 & M2
+>p : number
+
+    x.f();
+>x.f() : number
+>x.f : () => number
+>x : M1 & M2
+>f : () => number
+
+    Mixed5.p;
+>Mixed5.p : number
+>Mixed5 : typeof M1 & typeof M2
+>p : number
+
+    Mixed5.f();
+>Mixed5.f() : number
+>Mixed5.f : () => number
+>Mixed5 : typeof M1 & typeof M2
+>f : () => number
+}
+
+class C2 extends Mixed1 {
+>C2 : C2
+>Mixed1 : M1 & C1
+
+    constructor() {
+        super("hello");
+>super("hello") : void
+>super : typeof M1 & typeof C1
+>"hello" : "hello"
+
+        this.a;
+>this.a : number
+>this : this
+>a : number
+
+        this.b;
+>this.b : number
+>this : this
+>b : number
+
+        this.p;
+>this.p : number
+>this : this
+>p : number
+    }
+}
+
+class C3 extends Mixed3 {
+>C3 : C3
+>Mixed3 : M2 & M1 & C1
+
+    constructor() {
+        super(42);
+>super(42) : void
+>super : typeof M2 & typeof M1 & typeof C1
+>42 : 42
+
+        this.a;
+>this.a : number
+>this : this
+>a : number
+
+        this.b;
+>this.b : number
+>this : this
+>b : number
+
+        this.p;
+>this.p : number
+>this : this
+>p : number
+
+        this.f();
+>this.f() : number
+>this.f : () => number
+>this : this
+>f : () => number
+    }
+    f() { return super.f(); }
+>f : () => number
+>super.f() : number
+>super.f : () => number
+>super : M2 & M1 & C1
+>f : () => number
+}
+

From cc8bd6fc09f160aff2d2e77e9c84c3afd95022ff Mon Sep 17 00:00:00 2001
From: gdh1995 <gdh1995@qq.com>
Date: Sat, 28 Jan 2017 13:40:46 +0800
Subject: [PATCH 129/159] remove an odd new-line for catch clause

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

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 27285a4c2dc..8517d16d4e7 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1923,7 +1923,6 @@ namespace ts {
         }
 
         function emitCatchClause(node: CatchClause) {
-            writeLine();
             const openParenPos = writeToken(SyntaxKind.CatchKeyword, node.pos);
             write(" ");
             writeToken(SyntaxKind.OpenParenToken, openParenPos);

From 5282a8d0f5c1ddcf104eb44b36923f7f8d26a240 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 30 Jan 2017 08:55:32 -0800
Subject: [PATCH 130/159] ES6 target uses Object.assign for emitting spread

Also omits the __assign helper
---
 src/compiler/transformers/esnext.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index 0a529a8e871..ee92ec7c613 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -402,6 +402,11 @@ namespace ts {
     };
 
     export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) {
+        if (context.getCompilerOptions().target === ScriptTarget.ES2015) {
+            return createCall(createPropertyAccess(createIdentifier("Object"), "assign"),
+                              /*typeArguments*/ undefined,
+                              attributesSegments);
+        }
         context.requestEmitHelper(assignHelper);
         return createCall(
             getHelperName("__assign"),

From a67a7493317d2ceff8037a0da5f1cebb356e2960 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 30 Jan 2017 10:42:11 -0800
Subject: [PATCH 131/159] Emit Object.assign for spread for targets >= ES6

---
 src/compiler/transformers/esnext.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index ee92ec7c613..8b5a095a17e 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -402,7 +402,7 @@ namespace ts {
     };
 
     export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) {
-        if (context.getCompilerOptions().target === ScriptTarget.ES2015) {
+        if (context.getCompilerOptions().target >= ScriptTarget.ES2015) {
             return createCall(createPropertyAccess(createIdentifier("Object"), "assign"),
                               /*typeArguments*/ undefined,
                               attributesSegments);

From 46cdac1ec73a58fd8b0350e517d314395b9f0f0e Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 30 Jan 2017 10:42:39 -0800
Subject: [PATCH 132/159] Update baselines

---
 tests/baselines/reference/objectRest2.js     | 10 +---------
 tests/baselines/reference/objectRestForOf.js | 10 +---------
 2 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/tests/baselines/reference/objectRest2.js b/tests/baselines/reference/objectRest2.js
index 6abff9e56a1..e46d22db80a 100644
--- a/tests/baselines/reference/objectRest2.js
+++ b/tests/baselines/reference/objectRest2.js
@@ -15,14 +15,6 @@ rootConnection('test');
 
 
 //// [objectRest2.js]
-var __assign = (this && this.__assign) || Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t[p] = s[p];
-    }
-    return t;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -35,7 +27,7 @@ function rootConnection(name) {
     return {
         resolve: (context, args) => __awaiter(this, void 0, void 0, function* () {
             const { objects } = yield { objects: 12 };
-            return __assign({}, connectionFromArray(objects, args));
+            return Object.assign({}, connectionFromArray(objects, args));
         })
     };
 }
diff --git a/tests/baselines/reference/objectRestForOf.js b/tests/baselines/reference/objectRestForOf.js
index fd81f77512e..f8a88fe2868 100644
--- a/tests/baselines/reference/objectRestForOf.js
+++ b/tests/baselines/reference/objectRestForOf.js
@@ -15,14 +15,6 @@ for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 
 
 //// [objectRestForOf.js]
-var __assign = (this && this.__assign) || Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t[p] = s[p];
-    }
-    return t;
-};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -43,6 +35,6 @@ for (let _b of array) {
     ({ x: xx } = _b, rrestOff = __rest(_b, ["x"]));
     [xx, rrestOff];
 }
-for (const norest of array.map(a => (__assign({}, a, { x: 'a string' })))) {
+for (const norest of array.map(a => (Object.assign({}, a, { x: 'a string' })))) {
     [norest.x, norest.y];
 }

From 0165b71549533e3e6d810ffbe4dfb781b8794abc Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Mon, 30 Jan 2017 12:27:24 -0800
Subject: [PATCH 133/159] Embed comment emit inside of printer

---
 Jakefile.js                |    2 -
 src/compiler/comments.ts   |   30 +-
 src/compiler/core.ts       |    4 +-
 src/compiler/emitter.ts    | 2734 +++++++++++++++++++++++++++++++++++-
 src/compiler/printer.ts    | 2659 -----------------------------------
 src/compiler/tsconfig.json |    1 -
 src/compiler/types.ts      |   72 +-
 src/compiler/utilities.ts  |   19 +-
 src/harness/tsconfig.json  |    1 -
 src/services/tsconfig.json |    1 -
 10 files changed, 2793 insertions(+), 2730 deletions(-)
 delete mode 100644 src/compiler/printer.ts

diff --git a/Jakefile.js b/Jakefile.js
index a23b9cbe03c..3ee8476c842 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -84,7 +84,6 @@ var compilerSources = [
     "sourcemap.ts",
     "comments.ts",
     "declarationEmitter.ts",
-    "printer.ts",
     "emitter.ts",
     "program.ts",
     "commandLineParser.ts",
@@ -122,7 +121,6 @@ var servicesSources = [
     "sourcemap.ts",
     "comments.ts",
     "declarationEmitter.ts",
-    "printer.ts",
     "emitter.ts",
     "program.ts",
     "commandLineParser.ts",
diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts
index 3106d3ccfec..f69b4c546a0 100644
--- a/src/compiler/comments.ts
+++ b/src/compiler/comments.ts
@@ -5,13 +5,16 @@ namespace ts {
     export interface CommentWriter {
         reset(): void;
         setSourceFile(sourceFile: SourceFile): void;
+        setWriter(writer: EmitTextWriter): void;
         emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
         emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void): void;
         emitTrailingCommentsOfPosition(pos: number): void;
     }
 
-    export function createCommentWriter(writer: EmitTextWriter, compilerOptions: CompilerOptions, newLine: string, emitPos: (pos: number) => void): CommentWriter {
-        const extendedDiagnostics = compilerOptions.extendedDiagnostics;
+    export function createCommentWriter(printerOptions: PrinterOptions, emitPos: (pos: number) => void): CommentWriter {
+        const extendedDiagnostics = printerOptions.extendedDiagnostics;
+        const newLine = getNewLineCharacter(printerOptions);
+        let writer: EmitTextWriter;
         let containerPos = -1;
         let containerEnd = -1;
         let declarationListContainerEnd = -1;
@@ -20,10 +23,11 @@ namespace ts {
         let currentLineMap: number[];
         let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number}[];
         let hasWrittenComment = false;
-        let disabled: boolean = compilerOptions.removeComments;
+        let disabled: boolean = printerOptions.removeComments;
 
         return {
             reset,
+            setWriter,
             setSourceFile,
             emitNodeWithComments,
             emitBodyWithDetachedComments,
@@ -194,9 +198,9 @@ namespace ts {
             }
 
             // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
-            emitPos(commentPos);
+            if (emitPos) emitPos(commentPos);
             writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
-            emitPos(commentEnd);
+            if (emitPos) emitPos(commentEnd);
 
             if (hasTrailingNewLine) {
                 writer.writeLine();
@@ -216,9 +220,9 @@ namespace ts {
                 writer.write(" ");
             }
 
-            emitPos(commentPos);
+            if (emitPos) emitPos(commentPos);
             writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
-            emitPos(commentEnd);
+            if (emitPos) emitPos(commentEnd);
 
             if (hasTrailingNewLine) {
                 writer.writeLine();
@@ -244,9 +248,9 @@ namespace ts {
         function emitTrailingCommentOfPosition(commentPos: number, commentEnd: number, _kind: SyntaxKind, hasTrailingNewLine: boolean) {
             // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space
 
-            emitPos(commentPos);
+            if (emitPos) emitPos(commentPos);
             writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
-            emitPos(commentEnd);
+            if (emitPos) emitPos(commentEnd);
 
             if (hasTrailingNewLine) {
                 writer.writeLine();
@@ -282,6 +286,10 @@ namespace ts {
             detachedCommentsInfo = undefined;
         }
 
+        function setWriter(output: EmitTextWriter): void {
+            writer = output;
+        }
+
         function setSourceFile(sourceFile: SourceFile) {
             currentSourceFile = sourceFile;
             currentText = currentSourceFile.text;
@@ -319,9 +327,9 @@ namespace ts {
         }
 
         function writeComment(text: string, lineMap: number[], writer: EmitTextWriter, commentPos: number, commentEnd: number, newLine: string) {
-            emitPos(commentPos);
+            if (emitPos) emitPos(commentPos);
             writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine);
-            emitPos(commentEnd);
+            if (emitPos) emitPos(commentEnd);
         }
 
         /**
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index de3472afd88..b8097acaa71 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1447,11 +1447,11 @@ namespace ts {
         return /^\.\.?($|[\\/])/.test(moduleName);
     }
 
-    export function getEmitScriptTarget(compilerOptions: CompilerOptions) {
+    export function getEmitScriptTarget(compilerOptions: CompilerOptions | PrinterOptions) {
         return compilerOptions.target || ScriptTarget.ES3;
     }
 
-    export function getEmitModuleKind(compilerOptions: CompilerOptions) {
+    export function getEmitModuleKind(compilerOptions: CompilerOptions | PrinterOptions) {
         return typeof compilerOptions.module === "number" ?
             compilerOptions.module :
             getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? ModuleKind.ES2015 : ModuleKind.CommonJS;
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index dd823cf7994..b3bd594ae88 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -3,13 +3,12 @@
 /// <reference path="declarationEmitter.ts" />
 /// <reference path="sourcemap.ts" />
 /// <reference path="comments.ts" />
-/// <reference path="printer.ts" />
 
-/* @internal */
 namespace ts {
-    const id = (s: SourceFile) => s;
-    const nullTransformers: Transformer[] = [_ => id];
+    const delimiters = createDelimiterMap();
+    const brackets = createBracketsMap();
 
+    /*@internal*/
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
     export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean): EmitResult {
         const compilerOptions = host.getCompilerOptions();
@@ -17,10 +16,9 @@ namespace ts {
         const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
         const newLine = host.getNewLine();
-        const transformers: Transformer[] = emitOnlyDtsFiles ? nullTransformers : getTransformers(compilerOptions);
+        const transformers = emitOnlyDtsFiles ? [] : getTransformers(compilerOptions);
         const writer = createTextWriter(newLine);
         const sourceMap = createSourceMapWriter(host, writer);
-        const comments = createCommentWriter(writer, compilerOptions, newLine, sourceMap.emitPos);
 
         let currentSourceFile: SourceFile;
         let bundledHelpers: Map<boolean>;
@@ -33,7 +31,7 @@ namespace ts {
         const transform = transformFiles(resolver, host, sourceFiles, transformers);
 
         // Create a printer to print the nodes
-        const printer = createPrinter(writer, compilerOptions, {
+        const printer = createPrinter(compilerOptions, {
             // resolver hooks
             hasGlobalName: resolver.hasGlobalName,
 
@@ -44,11 +42,7 @@ namespace ts {
             // sourcemap hooks
             onEmitSourceMapOfNode: sourceMap.emitNodeWithSourceMap,
             onEmitSourceMapOfToken: sourceMap.emitTokenWithSourceMap,
-
-            // comment hooks
-            onEmitCommentsOfNode: comments.emitNodeWithComments,
-            onEmitDetachedCommentsOfNode: comments.emitBodyWithDetachedComments,
-            onEmitTrailingCommentsOfPosition: comments.emitTrailingCommentsOfPosition,
+            onEmitSourceMapOfPosition: sourceMap.emitPos,
 
             // emitter hooks
             onEmitHelpers: emitHelpers,
@@ -109,11 +103,11 @@ namespace ts {
             if (bundle) {
                 bundledHelpers = createMap<boolean>();
                 isOwnFileEmit = false;
-                printer.printBundle(bundle);
+                printer.writeBundle(bundle, writer);
             }
             else {
                 isOwnFileEmit = true;
-                printer.printFile(sourceFile);
+                printer.writeFile(sourceFile, writer);
             }
 
             writer.writeLine();
@@ -138,7 +132,6 @@ namespace ts {
 
             // Reset state
             sourceMap.reset();
-            comments.reset();
             writer.reset();
 
             currentSourceFile = undefined;
@@ -149,7 +142,6 @@ namespace ts {
         function setSourceFile(node: SourceFile) {
             currentSourceFile = node;
             sourceMap.setSourceFile(node);
-            comments.setSourceFile(node);
         }
 
         function emitHelpers(node: Node, writeLines: (text: string) => void) {
@@ -194,4 +186,2714 @@ namespace ts {
             return helpersEmitted;
         }
     }
+
+    export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): Printer {
+        const {
+            hasGlobalName,
+            onEmitSourceMapOfNode,
+            onEmitSourceMapOfToken,
+            onEmitSourceMapOfPosition,
+            onEmitNode,
+            onEmitHelpers,
+            onSetSourceFile,
+            onSubstituteNode,
+        } = handlers;
+
+        const newLine = getNewLineCharacter(printerOptions);
+        const languageVersion = getEmitScriptTarget(printerOptions);
+        const moduleKind = getEmitModuleKind(printerOptions);
+        const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition);
+        const {
+            emitNodeWithComments,
+            emitBodyWithDetachedComments,
+            emitTrailingCommentsOfPosition,
+        } = comments;
+
+        let currentSourceFile: SourceFile;
+        let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
+        let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
+        let generatedNames: Map<string>; // Set of names generated by the NameGenerator.
+        let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
+        let tempFlags: TempFlags; // TempFlags for the current name generation scope.
+        let writer: EmitTextWriter;
+        let ownWriter: EmitTextWriter;
+
+        reset();
+        return {
+            // public API
+            printNode,
+            printFile,
+            printBundle,
+
+            // internal API
+            writeNode,
+            writeFile,
+            writeBundle
+        };
+
+        function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string {
+            writeNode(hint, node, sourceFile, beginPrint());
+            return endPrint();
+        }
+
+        function printBundle(bundle: Bundle): string {
+            writeBundle(bundle, beginPrint());
+            return endPrint();
+        }
+
+        function printFile(sourceFile: SourceFile): string {
+            writeFile(sourceFile, beginPrint());
+            return endPrint();
+        }
+
+        function writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, output: EmitTextWriter) {
+            const previousWriter = writer;
+            setWriter(output);
+            print(hint, node, sourceFile);
+            reset();
+            writer = previousWriter;
+        }
+
+        function writeBundle(bundle: Bundle, output: EmitTextWriter) {
+            const previousWriter = writer;
+            setWriter(output);
+            if (moduleKind) {
+                emitHelpersIndirect(bundle);
+            }
+            for (const sourceFile of bundle.sourceFiles) {
+                print(EmitHint.SourceFile, sourceFile, sourceFile);
+            }
+            reset();
+            writer = previousWriter;
+        }
+
+        function writeFile(sourceFile: SourceFile, output: EmitTextWriter) {
+            const previousWriter = writer;
+            setWriter(output);
+            print(EmitHint.SourceFile, sourceFile, sourceFile);
+            reset();
+            writer = previousWriter;
+        }
+
+        function beginPrint() {
+            return ownWriter || (ownWriter = createTextWriter(newLine));
+        }
+
+        function endPrint() {
+            const text = writer.getText();
+            if (writer === ownWriter) {
+                writer.reset();
+            }
+
+            return text;
+        }
+
+        function print(hint: EmitHint, node: Node, sourceFile: SourceFile) {
+            setSourceFile(sourceFile);
+            pipelineEmitWithNotification(hint, node);
+        }
+
+        function setSourceFile(sourceFile: SourceFile) {
+            currentSourceFile = sourceFile;
+            comments.setSourceFile(sourceFile);
+            if (onSetSourceFile) {
+                onSetSourceFile(sourceFile);
+            }
+        }
+
+        function setWriter(output: EmitTextWriter | undefined) {
+            writer = output;
+            comments.setWriter(output);
+        }
+
+        function reset() {
+            nodeIdToGeneratedName = [];
+            autoGeneratedIdToGeneratedName = [];
+            generatedNames = createMap<string>();
+            tempFlagsStack = [];
+            tempFlags = TempFlags.Auto;
+            comments.reset();
+            setWriter(/*output*/ undefined);
+        }
+
+        function emit(node: Node, hint = EmitHint.Unspecified) {
+            pipelineEmitWithNotification(hint, node);
+        }
+
+        function emitIdentifierName(node: Identifier) {
+            pipelineEmitWithNotification(EmitHint.IdentifierName, node);
+        }
+
+        function emitExpression(node: Expression) {
+            pipelineEmitWithNotification(EmitHint.Expression, node);
+        }
+
+        function pipelineEmitWithNotification(hint: EmitHint, node: Node) {
+            if (onEmitNode) {
+                onEmitNode(hint, node, pipelineEmitWithComments);
+            }
+            else {
+                pipelineEmitWithComments(hint, node);
+            }
+        }
+
+        function pipelineEmitWithComments(hint: EmitHint, node: Node) {
+            if (emitNodeWithComments && hint !== EmitHint.SourceFile) {
+                emitNodeWithComments(hint, node, pipelineEmitWithSourceMap);
+            }
+            else {
+                pipelineEmitWithSourceMap(hint, node);
+            }
+        }
+
+        function pipelineEmitWithSourceMap(hint: EmitHint, node: Node) {
+            if (onEmitSourceMapOfNode && hint !== EmitHint.SourceFile && hint !== EmitHint.IdentifierName) {
+                onEmitSourceMapOfNode(hint, node, pipelineEmitWithSubstitution);
+            }
+            else {
+                pipelineEmitWithSubstitution(hint, node);
+            }
+        }
+
+        function pipelineEmitWithSubstitution(hint: EmitHint, node: Node) {
+            if (onSubstituteNode) {
+                onSubstituteNode(hint, node, pipelineEmitWithHint);
+            }
+            else {
+                pipelineEmitWithHint(hint, node);
+            }
+        }
+
+        function pipelineEmitWithHint(hint: EmitHint, node: Node): void {
+            switch (hint) {
+                case EmitHint.SourceFile: return pipelineEmitSourceFile(node);
+                case EmitHint.IdentifierName: return pipelineEmitIdentifierName(node);
+                case EmitHint.Expression: return pipelineEmitExpression(node);
+                case EmitHint.Unspecified: return pipelineEmitUnspecified(node);
+            }
+        }
+
+        function pipelineEmitSourceFile(node: Node): void {
+            Debug.assertNode(node, isSourceFile);
+            emitSourceFile(<SourceFile>node);
+        }
+
+        function pipelineEmitIdentifierName(node: Node): void {
+            Debug.assertNode(node, isIdentifier);
+            emitIdentifier(<Identifier>node);
+        }
+
+        function pipelineEmitUnspecified(node: Node): void {
+            const kind = node.kind;
+            switch (kind) {
+                // Pseudo-literals
+                case SyntaxKind.TemplateHead:
+                case SyntaxKind.TemplateMiddle:
+                case SyntaxKind.TemplateTail:
+                    return emitLiteral(<LiteralExpression>node);
+
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(<Identifier>node);
+
+                // Reserved words
+                case SyntaxKind.ConstKeyword:
+                case SyntaxKind.DefaultKeyword:
+                case SyntaxKind.ExportKeyword:
+                case SyntaxKind.VoidKeyword:
+
+                // Strict mode reserved words
+                case SyntaxKind.PrivateKeyword:
+                case SyntaxKind.ProtectedKeyword:
+                case SyntaxKind.PublicKeyword:
+                case SyntaxKind.StaticKeyword:
+
+                // Contextual keywords
+                case SyntaxKind.AbstractKeyword:
+                case SyntaxKind.AsKeyword:
+                case SyntaxKind.AnyKeyword:
+                case SyntaxKind.AsyncKeyword:
+                case SyntaxKind.AwaitKeyword:
+                case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.ConstructorKeyword:
+                case SyntaxKind.DeclareKeyword:
+                case SyntaxKind.GetKeyword:
+                case SyntaxKind.IsKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.NeverKeyword:
+                case SyntaxKind.ReadonlyKeyword:
+                case SyntaxKind.RequireKeyword:
+                case SyntaxKind.NumberKeyword:
+                case SyntaxKind.SetKeyword:
+                case SyntaxKind.StringKeyword:
+                case SyntaxKind.SymbolKeyword:
+                case SyntaxKind.TypeKeyword:
+                case SyntaxKind.UndefinedKeyword:
+                case SyntaxKind.FromKeyword:
+                case SyntaxKind.GlobalKeyword:
+                case SyntaxKind.OfKeyword:
+                    writeTokenText(kind);
+                    return;
+
+                // Parse tree nodes
+
+                // Names
+                case SyntaxKind.QualifiedName:
+                    return emitQualifiedName(<QualifiedName>node);
+                case SyntaxKind.ComputedPropertyName:
+                    return emitComputedPropertyName(<ComputedPropertyName>node);
+
+                // Signature elements
+                case SyntaxKind.TypeParameter:
+                    return emitTypeParameter(<TypeParameterDeclaration>node);
+                case SyntaxKind.Parameter:
+                    return emitParameter(<ParameterDeclaration>node);
+                case SyntaxKind.Decorator:
+                    return emitDecorator(<Decorator>node);
+
+                // Type members
+                case SyntaxKind.PropertySignature:
+                    return emitPropertySignature(<PropertySignature>node);
+                case SyntaxKind.PropertyDeclaration:
+                    return emitPropertyDeclaration(<PropertyDeclaration>node);
+                case SyntaxKind.MethodSignature:
+                    return emitMethodSignature(<MethodSignature>node);
+                case SyntaxKind.MethodDeclaration:
+                    return emitMethodDeclaration(<MethodDeclaration>node);
+                case SyntaxKind.Constructor:
+                    return emitConstructor(<ConstructorDeclaration>node);
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return emitAccessorDeclaration(<AccessorDeclaration>node);
+                case SyntaxKind.CallSignature:
+                    return emitCallSignature(<CallSignatureDeclaration>node);
+                case SyntaxKind.ConstructSignature:
+                    return emitConstructSignature(<ConstructSignatureDeclaration>node);
+                case SyntaxKind.IndexSignature:
+                    return emitIndexSignature(<IndexSignatureDeclaration>node);
+
+                // Types
+                case SyntaxKind.TypePredicate:
+                    return emitTypePredicate(<TypePredicateNode>node);
+                case SyntaxKind.TypeReference:
+                    return emitTypeReference(<TypeReferenceNode>node);
+                case SyntaxKind.FunctionType:
+                    return emitFunctionType(<FunctionTypeNode>node);
+                case SyntaxKind.ConstructorType:
+                    return emitConstructorType(<ConstructorTypeNode>node);
+                case SyntaxKind.TypeQuery:
+                    return emitTypeQuery(<TypeQueryNode>node);
+                case SyntaxKind.TypeLiteral:
+                    return emitTypeLiteral(<TypeLiteralNode>node);
+                case SyntaxKind.ArrayType:
+                    return emitArrayType(<ArrayTypeNode>node);
+                case SyntaxKind.TupleType:
+                    return emitTupleType(<TupleTypeNode>node);
+                case SyntaxKind.UnionType:
+                    return emitUnionType(<UnionTypeNode>node);
+                case SyntaxKind.IntersectionType:
+                    return emitIntersectionType(<IntersectionTypeNode>node);
+                case SyntaxKind.ParenthesizedType:
+                    return emitParenthesizedType(<ParenthesizedTypeNode>node);
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
+                case SyntaxKind.ThisType:
+                    return emitThisType();
+                case SyntaxKind.TypeOperator:
+                    return emitTypeOperator(<TypeOperatorNode>node);
+                case SyntaxKind.IndexedAccessType:
+                    return emitIndexedAccessType(<IndexedAccessTypeNode>node);
+                case SyntaxKind.MappedType:
+                    return emitMappedType(<MappedTypeNode>node);
+                case SyntaxKind.LiteralType:
+                    return emitLiteralType(<LiteralTypeNode>node);
+
+                // Binding patterns
+                case SyntaxKind.ObjectBindingPattern:
+                    return emitObjectBindingPattern(<ObjectBindingPattern>node);
+                case SyntaxKind.ArrayBindingPattern:
+                    return emitArrayBindingPattern(<ArrayBindingPattern>node);
+                case SyntaxKind.BindingElement:
+                    return emitBindingElement(<BindingElement>node);
+
+                // Misc
+                case SyntaxKind.TemplateSpan:
+                    return emitTemplateSpan(<TemplateSpan>node);
+                case SyntaxKind.SemicolonClassElement:
+                    return emitSemicolonClassElement();
+
+                // Statements
+                case SyntaxKind.Block:
+                    return emitBlock(<Block>node);
+                case SyntaxKind.VariableStatement:
+                    return emitVariableStatement(<VariableStatement>node);
+                case SyntaxKind.EmptyStatement:
+                    return emitEmptyStatement();
+                case SyntaxKind.ExpressionStatement:
+                    return emitExpressionStatement(<ExpressionStatement>node);
+                case SyntaxKind.IfStatement:
+                    return emitIfStatement(<IfStatement>node);
+                case SyntaxKind.DoStatement:
+                    return emitDoStatement(<DoStatement>node);
+                case SyntaxKind.WhileStatement:
+                    return emitWhileStatement(<WhileStatement>node);
+                case SyntaxKind.ForStatement:
+                    return emitForStatement(<ForStatement>node);
+                case SyntaxKind.ForInStatement:
+                    return emitForInStatement(<ForInStatement>node);
+                case SyntaxKind.ForOfStatement:
+                    return emitForOfStatement(<ForOfStatement>node);
+                case SyntaxKind.ContinueStatement:
+                    return emitContinueStatement(<ContinueStatement>node);
+                case SyntaxKind.BreakStatement:
+                    return emitBreakStatement(<BreakStatement>node);
+                case SyntaxKind.ReturnStatement:
+                    return emitReturnStatement(<ReturnStatement>node);
+                case SyntaxKind.WithStatement:
+                    return emitWithStatement(<WithStatement>node);
+                case SyntaxKind.SwitchStatement:
+                    return emitSwitchStatement(<SwitchStatement>node);
+                case SyntaxKind.LabeledStatement:
+                    return emitLabeledStatement(<LabeledStatement>node);
+                case SyntaxKind.ThrowStatement:
+                    return emitThrowStatement(<ThrowStatement>node);
+                case SyntaxKind.TryStatement:
+                    return emitTryStatement(<TryStatement>node);
+                case SyntaxKind.DebuggerStatement:
+                    return emitDebuggerStatement(<DebuggerStatement>node);
+
+                // Declarations
+                case SyntaxKind.VariableDeclaration:
+                    return emitVariableDeclaration(<VariableDeclaration>node);
+                case SyntaxKind.VariableDeclarationList:
+                    return emitVariableDeclarationList(<VariableDeclarationList>node);
+                case SyntaxKind.FunctionDeclaration:
+                    return emitFunctionDeclaration(<FunctionDeclaration>node);
+                case SyntaxKind.ClassDeclaration:
+                    return emitClassDeclaration(<ClassDeclaration>node);
+                case SyntaxKind.InterfaceDeclaration:
+                    return emitInterfaceDeclaration(<InterfaceDeclaration>node);
+                case SyntaxKind.TypeAliasDeclaration:
+                    return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);
+                case SyntaxKind.EnumDeclaration:
+                    return emitEnumDeclaration(<EnumDeclaration>node);
+                case SyntaxKind.ModuleDeclaration:
+                    return emitModuleDeclaration(<ModuleDeclaration>node);
+                case SyntaxKind.ModuleBlock:
+                    return emitModuleBlock(<ModuleBlock>node);
+                case SyntaxKind.CaseBlock:
+                    return emitCaseBlock(<CaseBlock>node);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                case SyntaxKind.ImportDeclaration:
+                    return emitImportDeclaration(<ImportDeclaration>node);
+                case SyntaxKind.ImportClause:
+                    return emitImportClause(<ImportClause>node);
+                case SyntaxKind.NamespaceImport:
+                    return emitNamespaceImport(<NamespaceImport>node);
+                case SyntaxKind.NamedImports:
+                    return emitNamedImports(<NamedImports>node);
+                case SyntaxKind.ImportSpecifier:
+                    return emitImportSpecifier(<ImportSpecifier>node);
+                case SyntaxKind.ExportAssignment:
+                    return emitExportAssignment(<ExportAssignment>node);
+                case SyntaxKind.ExportDeclaration:
+                    return emitExportDeclaration(<ExportDeclaration>node);
+                case SyntaxKind.NamedExports:
+                    return emitNamedExports(<NamedExports>node);
+                case SyntaxKind.ExportSpecifier:
+                    return emitExportSpecifier(<ExportSpecifier>node);
+                case SyntaxKind.MissingDeclaration:
+                    return;
+
+                // Module references
+                case SyntaxKind.ExternalModuleReference:
+                    return emitExternalModuleReference(<ExternalModuleReference>node);
+
+                // JSX (non-expression)
+                case SyntaxKind.JsxText:
+                    return emitJsxText(<JsxText>node);
+                case SyntaxKind.JsxOpeningElement:
+                    return emitJsxOpeningElement(<JsxOpeningElement>node);
+                case SyntaxKind.JsxClosingElement:
+                    return emitJsxClosingElement(<JsxClosingElement>node);
+                case SyntaxKind.JsxAttribute:
+                    return emitJsxAttribute(<JsxAttribute>node);
+                case SyntaxKind.JsxSpreadAttribute:
+                    return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);
+                case SyntaxKind.JsxExpression:
+                    return emitJsxExpression(<JsxExpression>node);
+
+                // Clauses
+                case SyntaxKind.CaseClause:
+                    return emitCaseClause(<CaseClause>node);
+                case SyntaxKind.DefaultClause:
+                    return emitDefaultClause(<DefaultClause>node);
+                case SyntaxKind.HeritageClause:
+                    return emitHeritageClause(<HeritageClause>node);
+                case SyntaxKind.CatchClause:
+                    return emitCatchClause(<CatchClause>node);
+
+                // Property assignments
+                case SyntaxKind.PropertyAssignment:
+                    return emitPropertyAssignment(<PropertyAssignment>node);
+                case SyntaxKind.ShorthandPropertyAssignment:
+                    return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);
+                case SyntaxKind.SpreadAssignment:
+                    return emitSpreadAssignment(node as SpreadAssignment);
+
+                // Enum
+                case SyntaxKind.EnumMember:
+                    return emitEnumMember(<EnumMember>node);
+
+                // JSDoc nodes (ignored)
+                // Transformation nodes (ignored)
+            }
+
+            // If the node is an expression, try to emit it as an expression with
+            // substitution.
+            if (isExpression(node)) {
+                return pipelineEmitWithSubstitution(EmitHint.Expression, node);
+            }
+        }
+
+        function pipelineEmitExpression(node: Node): void {
+            const kind = node.kind;
+            switch (kind) {
+                // Literals
+                case SyntaxKind.NumericLiteral:
+                    return emitNumericLiteral(<NumericLiteral>node);
+
+                case SyntaxKind.StringLiteral:
+                case SyntaxKind.RegularExpressionLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    return emitLiteral(<LiteralExpression>node);
+
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(<Identifier>node);
+
+                // Reserved words
+                case SyntaxKind.FalseKeyword:
+                case SyntaxKind.NullKeyword:
+                case SyntaxKind.SuperKeyword:
+                case SyntaxKind.TrueKeyword:
+                case SyntaxKind.ThisKeyword:
+                    writeTokenText(kind);
+                    return;
+
+                // Expressions
+                case SyntaxKind.ArrayLiteralExpression:
+                    return emitArrayLiteralExpression(<ArrayLiteralExpression>node);
+                case SyntaxKind.ObjectLiteralExpression:
+                    return emitObjectLiteralExpression(<ObjectLiteralExpression>node);
+                case SyntaxKind.PropertyAccessExpression:
+                    return emitPropertyAccessExpression(<PropertyAccessExpression>node);
+                case SyntaxKind.ElementAccessExpression:
+                    return emitElementAccessExpression(<ElementAccessExpression>node);
+                case SyntaxKind.CallExpression:
+                    return emitCallExpression(<CallExpression>node);
+                case SyntaxKind.NewExpression:
+                    return emitNewExpression(<NewExpression>node);
+                case SyntaxKind.TaggedTemplateExpression:
+                    return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
+                case SyntaxKind.TypeAssertionExpression:
+                    return emitTypeAssertionExpression(<TypeAssertion>node);
+                case SyntaxKind.ParenthesizedExpression:
+                    return emitParenthesizedExpression(<ParenthesizedExpression>node);
+                case SyntaxKind.FunctionExpression:
+                    return emitFunctionExpression(<FunctionExpression>node);
+                case SyntaxKind.ArrowFunction:
+                    return emitArrowFunction(<ArrowFunction>node);
+                case SyntaxKind.DeleteExpression:
+                    return emitDeleteExpression(<DeleteExpression>node);
+                case SyntaxKind.TypeOfExpression:
+                    return emitTypeOfExpression(<TypeOfExpression>node);
+                case SyntaxKind.VoidExpression:
+                    return emitVoidExpression(<VoidExpression>node);
+                case SyntaxKind.AwaitExpression:
+                    return emitAwaitExpression(<AwaitExpression>node);
+                case SyntaxKind.PrefixUnaryExpression:
+                    return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);
+                case SyntaxKind.PostfixUnaryExpression:
+                    return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);
+                case SyntaxKind.BinaryExpression:
+                    return emitBinaryExpression(<BinaryExpression>node);
+                case SyntaxKind.ConditionalExpression:
+                    return emitConditionalExpression(<ConditionalExpression>node);
+                case SyntaxKind.TemplateExpression:
+                    return emitTemplateExpression(<TemplateExpression>node);
+                case SyntaxKind.YieldExpression:
+                    return emitYieldExpression(<YieldExpression>node);
+                case SyntaxKind.SpreadElement:
+                    return emitSpreadExpression(<SpreadElement>node);
+                case SyntaxKind.ClassExpression:
+                    return emitClassExpression(<ClassExpression>node);
+                case SyntaxKind.OmittedExpression:
+                    return;
+                case SyntaxKind.AsExpression:
+                    return emitAsExpression(<AsExpression>node);
+                case SyntaxKind.NonNullExpression:
+                    return emitNonNullExpression(<NonNullExpression>node);
+                case SyntaxKind.MetaProperty:
+                    return emitMetaProperty(<MetaProperty>node);
+
+                // JSX
+                case SyntaxKind.JsxElement:
+                    return emitJsxElement(<JsxElement>node);
+                case SyntaxKind.JsxSelfClosingElement:
+                    return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);
+
+                // Transformation nodes
+                case SyntaxKind.PartiallyEmittedExpression:
+                    return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
+            }
+        }
+
+        function emitBodyIndirect(node: Node, elements: NodeArray<Node>, emitCallback: (node: Node) => void): void {
+            if (emitBodyWithDetachedComments) {
+                emitBodyWithDetachedComments(node, elements, emitCallback);
+            }
+            else {
+                emitCallback(node);
+            }
+        }
+
+        function emitHelpersIndirect(node: Node) {
+            if (onEmitHelpers) {
+                onEmitHelpers(node, writeLines);
+            }
+        }
+
+        //
+        // Literals/Pseudo-literals
+        //
+
+        // SyntaxKind.NumericLiteral
+        function emitNumericLiteral(node: NumericLiteral) {
+            emitLiteral(node);
+            if (node.trailingComment) {
+                write(` /*${node.trailingComment}*/`);
+            }
+        }
+
+        // SyntaxKind.StringLiteral
+        // SyntaxKind.RegularExpressionLiteral
+        // SyntaxKind.NoSubstitutionTemplateLiteral
+        // SyntaxKind.TemplateHead
+        // SyntaxKind.TemplateMiddle
+        // SyntaxKind.TemplateTail
+        function emitLiteral(node: LiteralLikeNode) {
+            const text = getLiteralTextOfNode(node);
+            if ((printerOptions.sourceMap || printerOptions.inlineSourceMap)
+                && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
+                writer.writeLiteral(text);
+            }
+            else {
+                write(text);
+            }
+        }
+
+        //
+        // Identifiers
+        //
+
+        function emitIdentifier(node: Identifier) {
+            write(getTextOfNode(node, /*includeTrivia*/ false));
+        }
+
+        //
+        // Names
+        //
+
+        function emitQualifiedName(node: QualifiedName) {
+            emitEntityName(node.left);
+            write(".");
+            emit(node.right);
+        }
+
+        function emitEntityName(node: EntityName) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        function emitComputedPropertyName(node: ComputedPropertyName) {
+            write("[");
+            emitExpression(node.expression);
+            write("]");
+        }
+
+        //
+        // Signature elements
+        //
+
+        function emitTypeParameter(node: TypeParameterDeclaration) {
+            emit(node.name);
+            emitWithPrefix(" extends ", node.constraint);
+        }
+
+        function emitParameter(node: ParameterDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            writeIfPresent(node.dotDotDotToken, "...");
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitExpressionWithPrefix(" = ", node.initializer);
+            emitWithPrefix(": ", node.type);
+        }
+
+        function emitDecorator(decorator: Decorator) {
+            write("@");
+            emitExpression(decorator.expression);
+        }
+
+        //
+        // Type members
+        //
+
+        function emitPropertySignature(node: PropertySignature) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitPropertyDeclaration(node: PropertyDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            emitWithPrefix(": ", node.type);
+            emitExpressionWithPrefix(" = ", node.initializer);
+            write(";");
+        }
+
+        function emitMethodSignature(node: MethodSignature) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emit(node.name);
+            writeIfPresent(node.questionToken, "?");
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitMethodDeclaration(node: MethodDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            writeIfPresent(node.asteriskToken, "*");
+            emit(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitConstructor(node: ConstructorDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("constructor");
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitAccessorDeclaration(node: AccessorDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write(node.kind === SyntaxKind.GetAccessor ? "get " : "set ");
+            emit(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitCallSignature(node: CallSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitConstructSignature(node: ConstructSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("new ");
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitIndexSignature(node: IndexSignatureDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitParametersForIndexSignature(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(";");
+        }
+
+        function emitSemicolonClassElement() {
+            write(";");
+        }
+
+        //
+        // Types
+        //
+
+        function emitTypePredicate(node: TypePredicateNode) {
+            emit(node.parameterName);
+            write(" is ");
+            emit(node.type);
+        }
+
+        function emitTypeReference(node: TypeReferenceNode) {
+            emit(node.typeName);
+            emitTypeArguments(node, node.typeArguments);
+        }
+
+        function emitFunctionType(node: FunctionTypeNode) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            write(" => ");
+            emit(node.type);
+        }
+
+        function emitConstructorType(node: ConstructorTypeNode) {
+            write("new ");
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            write(" => ");
+            emit(node.type);
+        }
+
+        function emitTypeQuery(node: TypeQueryNode) {
+            write("typeof ");
+            emit(node.exprName);
+        }
+
+        function emitTypeLiteral(node: TypeLiteralNode) {
+            write("{");
+            emitList(node, node.members, ListFormat.TypeLiteralMembers);
+            write("}");
+        }
+
+        function emitArrayType(node: ArrayTypeNode) {
+            emit(node.elementType);
+            write("[]");
+        }
+
+        function emitTupleType(node: TupleTypeNode) {
+            write("[");
+            emitList(node, node.elementTypes, ListFormat.TupleTypeElements);
+            write("]");
+        }
+
+        function emitUnionType(node: UnionTypeNode) {
+            emitList(node, node.types, ListFormat.UnionTypeConstituents);
+        }
+
+        function emitIntersectionType(node: IntersectionTypeNode) {
+            emitList(node, node.types, ListFormat.IntersectionTypeConstituents);
+        }
+
+        function emitParenthesizedType(node: ParenthesizedTypeNode) {
+            write("(");
+            emit(node.type);
+            write(")");
+        }
+
+        function emitThisType() {
+            write("this");
+        }
+
+        function emitTypeOperator(node: TypeOperatorNode) {
+            writeTokenText(node.operator);
+            write(" ");
+            emit(node.type);
+        }
+
+        function emitIndexedAccessType(node: IndexedAccessTypeNode) {
+            emit(node.objectType);
+            write("[");
+            emit(node.indexType);
+            write("]");
+        }
+
+        function emitMappedType(node: MappedTypeNode) {
+            write("{");
+            writeLine();
+            increaseIndent();
+            writeIfPresent(node.readonlyToken, "readonly ");
+            write("[");
+            emit(node.typeParameter.name);
+            write(" in ");
+            emit(node.typeParameter.constraint);
+            write("]");
+            writeIfPresent(node.questionToken, "?");
+            write(": ");
+            emit(node.type);
+            write(";");
+            writeLine();
+            decreaseIndent();
+            write("}");
+        }
+
+        function emitLiteralType(node: LiteralTypeNode) {
+            emitExpression(node.literal);
+        }
+
+        //
+        // Binding patterns
+        //
+
+        function emitObjectBindingPattern(node: ObjectBindingPattern) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("{}");
+            }
+            else {
+                write("{");
+                emitList(node, elements, ListFormat.ObjectBindingPatternElements);
+                write("}");
+            }
+        }
+
+        function emitArrayBindingPattern(node: ArrayBindingPattern) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("[]");
+            }
+            else {
+                write("[");
+                emitList(node, node.elements, ListFormat.ArrayBindingPatternElements);
+                write("]");
+            }
+        }
+
+        function emitBindingElement(node: BindingElement) {
+            emitWithSuffix(node.propertyName, ": ");
+            writeIfPresent(node.dotDotDotToken, "...");
+            emit(node.name);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        //
+        // Expressions
+        //
+
+        function emitArrayLiteralExpression(node: ArrayLiteralExpression) {
+            const elements = node.elements;
+            if (elements.length === 0) {
+                write("[]");
+            }
+            else {
+                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
+                emitExpressionList(node, elements, ListFormat.ArrayLiteralExpressionElements | preferNewLine);
+            }
+        }
+
+        function emitObjectLiteralExpression(node: ObjectLiteralExpression) {
+            const properties = node.properties;
+            if (properties.length === 0) {
+                write("{}");
+            }
+            else {
+                const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+                if (indentedFlag) {
+                    increaseIndent();
+                }
+
+                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
+                const allowTrailingComma = languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None;
+                emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine);
+
+                if (indentedFlag) {
+                    decreaseIndent();
+                }
+            }
+        }
+
+        function emitPropertyAccessExpression(node: PropertyAccessExpression) {
+            let indentBeforeDot = false;
+            let indentAfterDot = false;
+            if (!(getEmitFlags(node) & EmitFlags.NoIndentation)) {
+                const dotRangeStart = node.expression.end;
+                const dotRangeEnd = skipTrivia(currentSourceFile.text, node.expression.end) + 1;
+                const dotToken = <Node>{ kind: SyntaxKind.DotToken, pos: dotRangeStart, end: dotRangeEnd };
+                indentBeforeDot = needsIndentation(node, node.expression, dotToken);
+                indentAfterDot = needsIndentation(node, dotToken, node.name);
+            }
+
+            emitExpression(node.expression);
+            increaseIndentIf(indentBeforeDot);
+
+            const shouldEmitDotDot = !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
+            write(shouldEmitDotDot ? ".." : ".");
+
+            increaseIndentIf(indentAfterDot);
+            emit(node.name);
+            decreaseIndentIf(indentBeforeDot, indentAfterDot);
+        }
+
+        // 1..toString is a valid property access, emit a dot after the literal
+        // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal
+        function needsDotDotForPropertyAccess(expression: Expression) {
+            if (expression.kind === SyntaxKind.NumericLiteral) {
+                // check if numeric literal is a decimal literal that was originally written with a dot
+                const text = getLiteralTextOfNode(<LiteralExpression>expression);
+                return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None
+                    && !(<LiteralExpression>expression).isOctalLiteral
+                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
+            }
+            else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
+                // check if constant enum value is integer
+                const constantValue = getConstantValue(expression);
+                // isFinite handles cases when constantValue is undefined
+                return isFinite(constantValue)
+                    && Math.floor(constantValue) === constantValue
+                    && printerOptions.removeComments;
+            }
+        }
+
+        function emitElementAccessExpression(node: ElementAccessExpression) {
+            emitExpression(node.expression);
+            write("[");
+            emitExpression(node.argumentExpression);
+            write("]");
+        }
+
+        function emitCallExpression(node: CallExpression) {
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+            emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
+        }
+
+        function emitNewExpression(node: NewExpression) {
+            write("new ");
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+            emitExpressionList(node, node.arguments, ListFormat.NewExpressionArguments);
+        }
+
+        function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
+            emitExpression(node.tag);
+            write(" ");
+            emitExpression(node.template);
+        }
+
+        function emitTypeAssertionExpression(node: TypeAssertion) {
+            write("<");
+            emit(node.type);
+            write(">");
+            emitExpression(node.expression);
+        }
+
+        function emitParenthesizedExpression(node: ParenthesizedExpression) {
+            write("(");
+            emitExpression(node.expression);
+            write(")");
+        }
+
+        function emitFunctionExpression(node: FunctionExpression) {
+            emitFunctionDeclarationOrExpression(node);
+        }
+
+        function emitArrowFunction(node: ArrowFunction) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            emitSignatureAndBody(node, emitArrowFunctionHead);
+        }
+
+        function emitArrowFunctionHead(node: ArrowFunction) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParametersForArrow(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+            write(" =>");
+        }
+
+        function emitDeleteExpression(node: DeleteExpression) {
+            write("delete ");
+            emitExpression(node.expression);
+        }
+
+        function emitTypeOfExpression(node: TypeOfExpression) {
+            write("typeof ");
+            emitExpression(node.expression);
+        }
+
+        function emitVoidExpression(node: VoidExpression) {
+            write("void ");
+            emitExpression(node.expression);
+        }
+
+        function emitAwaitExpression(node: AwaitExpression) {
+            write("await ");
+            emitExpression(node.expression);
+        }
+
+        function emitPrefixUnaryExpression(node: PrefixUnaryExpression) {
+            writeTokenText(node.operator);
+            if (shouldEmitWhitespaceBeforeOperand(node)) {
+                write(" ");
+            }
+            emitExpression(node.operand);
+        }
+
+        function shouldEmitWhitespaceBeforeOperand(node: PrefixUnaryExpression) {
+            // In some cases, we need to emit a space between the operator and the operand. One obvious case
+            // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
+            // and minus expressions in certain cases. Specifically, consider the following two cases (parens
+            // are just for clarity of exposition, and not part of the source code):
+            //
+            //  (+(+1))
+            //  (+(++1))
+            //
+            // We need to emit a space in both cases. In the first case, the absence of a space will make
+            // the resulting expression a prefix increment operation. And in the second, it will make the resulting
+            // expression a prefix increment whose operand is a plus expression - (++(+x))
+            // The same is true of minus of course.
+            const operand = node.operand;
+            return operand.kind === SyntaxKind.PrefixUnaryExpression
+                && ((node.operator === SyntaxKind.PlusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusPlusToken))
+                || (node.operator === SyntaxKind.MinusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusMinusToken)));
+        }
+
+        function emitPostfixUnaryExpression(node: PostfixUnaryExpression) {
+            emitExpression(node.operand);
+            writeTokenText(node.operator);
+        }
+
+        function emitBinaryExpression(node: BinaryExpression) {
+            const isCommaOperator = node.operatorToken.kind !== SyntaxKind.CommaToken;
+            const indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken);
+            const indentAfterOperator = needsIndentation(node, node.operatorToken, node.right);
+
+            emitExpression(node.left);
+            increaseIndentIf(indentBeforeOperator, isCommaOperator ? " " : undefined);
+            writeTokenText(node.operatorToken.kind);
+            increaseIndentIf(indentAfterOperator, " ");
+            emitExpression(node.right);
+            decreaseIndentIf(indentBeforeOperator, indentAfterOperator);
+        }
+
+        function emitConditionalExpression(node: ConditionalExpression) {
+            const indentBeforeQuestion = needsIndentation(node, node.condition, node.questionToken);
+            const indentAfterQuestion = needsIndentation(node, node.questionToken, node.whenTrue);
+            const indentBeforeColon = needsIndentation(node, node.whenTrue, node.colonToken);
+            const indentAfterColon = needsIndentation(node, node.colonToken, node.whenFalse);
+
+            emitExpression(node.condition);
+            increaseIndentIf(indentBeforeQuestion, " ");
+            write("?");
+            increaseIndentIf(indentAfterQuestion, " ");
+            emitExpression(node.whenTrue);
+            decreaseIndentIf(indentBeforeQuestion, indentAfterQuestion);
+
+            increaseIndentIf(indentBeforeColon, " ");
+            write(":");
+            increaseIndentIf(indentAfterColon, " ");
+            emitExpression(node.whenFalse);
+            decreaseIndentIf(indentBeforeColon, indentAfterColon);
+        }
+
+        function emitTemplateExpression(node: TemplateExpression) {
+            emit(node.head);
+            emitList(node, node.templateSpans, ListFormat.TemplateExpressionSpans);
+        }
+
+        function emitYieldExpression(node: YieldExpression) {
+            write(node.asteriskToken ? "yield*" : "yield");
+            emitExpressionWithPrefix(" ", node.expression);
+        }
+
+        function emitSpreadExpression(node: SpreadElement) {
+            write("...");
+            emitExpression(node.expression);
+        }
+
+        function emitClassExpression(node: ClassExpression) {
+            emitClassDeclarationOrExpression(node);
+        }
+
+        function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
+            emitExpression(node.expression);
+            emitTypeArguments(node, node.typeArguments);
+        }
+
+        function emitAsExpression(node: AsExpression) {
+            emitExpression(node.expression);
+            if (node.type) {
+                write(" as ");
+                emit(node.type);
+            }
+        }
+
+        function emitNonNullExpression(node: NonNullExpression) {
+            emitExpression(node.expression);
+            write("!");
+        }
+
+        function emitMetaProperty(node: MetaProperty) {
+            writeToken(node.keywordToken, node.pos);
+            write(".");
+            emit(node.name);
+        }
+
+        //
+        // Misc
+        //
+
+        function emitTemplateSpan(node: TemplateSpan) {
+            emitExpression(node.expression);
+            emit(node.literal);
+        }
+
+        //
+        // Statements
+        //
+
+        function emitBlock(node: Block) {
+            if (isSingleLineEmptyBlock(node)) {
+                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
+                write(" ");
+                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
+            }
+            else {
+                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
+                emitBlockStatements(node);
+                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
+            }
+        }
+
+        function emitBlockStatements(node: BlockLike) {
+            if (getEmitFlags(node) & EmitFlags.SingleLine) {
+                emitList(node, node.statements, ListFormat.SingleLineBlockStatements);
+            }
+            else {
+                emitList(node, node.statements, ListFormat.MultiLineBlockStatements);
+            }
+        }
+
+        function emitVariableStatement(node: VariableStatement) {
+            emitModifiers(node, node.modifiers);
+            emit(node.declarationList);
+            write(";");
+        }
+
+        function emitEmptyStatement() {
+            write(";");
+        }
+
+        function emitExpressionStatement(node: ExpressionStatement) {
+            emitExpression(node.expression);
+            write(";");
+        }
+
+        function emitIfStatement(node: IfStatement) {
+            const openParenPos = writeToken(SyntaxKind.IfKeyword, node.pos, node);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos, node);
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end, node);
+            emitEmbeddedStatement(node, node.thenStatement);
+            if (node.elseStatement) {
+                writeLineOrSpace(node);
+                writeToken(SyntaxKind.ElseKeyword, node.thenStatement.end, node);
+                if (node.elseStatement.kind === SyntaxKind.IfStatement) {
+                    write(" ");
+                    emit(node.elseStatement);
+                }
+                else {
+                    emitEmbeddedStatement(node, node.elseStatement);
+                }
+            }
+        }
+
+        function emitDoStatement(node: DoStatement) {
+            write("do");
+            emitEmbeddedStatement(node, node.statement);
+            if (isBlock(node.statement)) {
+                write(" ");
+            }
+            else {
+                writeLineOrSpace(node);
+            }
+
+            write("while (");
+            emitExpression(node.expression);
+            write(");");
+        }
+
+        function emitWhileStatement(node: WhileStatement) {
+            write("while (");
+            emitExpression(node.expression);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForStatement(node: ForStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos, /*contextNode*/ node);
+            emitForBinding(node.initializer);
+            write(";");
+            emitExpressionWithPrefix(" ", node.condition);
+            write(";");
+            emitExpressionWithPrefix(" ", node.incrementor);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForInStatement(node: ForInStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitForBinding(node.initializer);
+            write(" in ");
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForOfStatement(node: ForOfStatement) {
+            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitForBinding(node.initializer);
+            write(" of ");
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitForBinding(node: VariableDeclarationList | Expression) {
+            if (node !== undefined) {
+                if (node.kind === SyntaxKind.VariableDeclarationList) {
+                    emit(node);
+                }
+                else {
+                    emitExpression(<Expression>node);
+                }
+            }
+        }
+
+        function emitContinueStatement(node: ContinueStatement) {
+            writeToken(SyntaxKind.ContinueKeyword, node.pos);
+            emitWithPrefix(" ", node.label);
+            write(";");
+        }
+
+        function emitBreakStatement(node: BreakStatement) {
+            writeToken(SyntaxKind.BreakKeyword, node.pos);
+            emitWithPrefix(" ", node.label);
+            write(";");
+        }
+
+        function emitReturnStatement(node: ReturnStatement) {
+            writeToken(SyntaxKind.ReturnKeyword, node.pos, /*contextNode*/ node);
+            emitExpressionWithPrefix(" ", node.expression);
+            write(";");
+        }
+
+        function emitWithStatement(node: WithStatement) {
+            write("with (");
+            emitExpression(node.expression);
+            write(")");
+            emitEmbeddedStatement(node, node.statement);
+        }
+
+        function emitSwitchStatement(node: SwitchStatement) {
+            const openParenPos = writeToken(SyntaxKind.SwitchKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emitExpression(node.expression);
+            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
+            write(" ");
+            emit(node.caseBlock);
+        }
+
+        function emitLabeledStatement(node: LabeledStatement) {
+            emit(node.label);
+            write(": ");
+            emit(node.statement);
+        }
+
+        function emitThrowStatement(node: ThrowStatement) {
+            write("throw");
+            emitExpressionWithPrefix(" ", node.expression);
+            write(";");
+        }
+
+        function emitTryStatement(node: TryStatement) {
+            write("try ");
+            emit(node.tryBlock);
+            if (node.catchClause) {
+                writeLineOrSpace(node);
+                emit(node.catchClause);
+            }
+            if (node.finallyBlock) {
+                writeLineOrSpace(node);
+                write("finally ");
+                emit(node.finallyBlock);
+            }
+        }
+
+        function emitDebuggerStatement(node: DebuggerStatement) {
+            writeToken(SyntaxKind.DebuggerKeyword, node.pos);
+            write(";");
+        }
+
+        //
+        // Declarations
+        //
+
+        function emitVariableDeclaration(node: VariableDeclaration) {
+            emit(node.name);
+            emitWithPrefix(": ", node.type);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        function emitVariableDeclarationList(node: VariableDeclarationList) {
+            write(isLet(node) ? "let " : isConst(node) ? "const " : "var ");
+            emitList(node, node.declarations, ListFormat.VariableDeclarationList);
+        }
+
+        function emitFunctionDeclaration(node: FunctionDeclaration) {
+            emitFunctionDeclarationOrExpression(node);
+        }
+
+        function emitFunctionDeclarationOrExpression(node: FunctionDeclaration | FunctionExpression) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write(node.asteriskToken ? "function* " : "function ");
+            emitIdentifierName(node.name);
+            emitSignatureAndBody(node, emitSignatureHead);
+        }
+
+        function emitSignatureAndBody(node: FunctionLikeDeclaration, emitSignatureHead: (node: SignatureDeclaration) => void) {
+            const body = node.body;
+            if (body) {
+                if (isBlock(body)) {
+                    const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+                    if (indentedFlag) {
+                        increaseIndent();
+                    }
+
+                    if (getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
+                        emitSignatureHead(node);
+                        emitBlockFunctionBody(body);
+                    }
+                    else {
+                        pushNameGenerationScope();
+                        emitSignatureHead(node);
+                        emitBlockFunctionBody(body);
+                        popNameGenerationScope();
+                    }
+
+                    if (indentedFlag) {
+                        decreaseIndent();
+                    }
+                }
+                else {
+                    emitSignatureHead(node);
+                    write(" ");
+                    emitExpression(body);
+                }
+            }
+            else {
+                emitSignatureHead(node);
+                write(";");
+            }
+
+        }
+
+        function emitSignatureHead(node: FunctionDeclaration | FunctionExpression | MethodDeclaration | AccessorDeclaration | ConstructorDeclaration) {
+            emitTypeParameters(node, node.typeParameters);
+            emitParameters(node, node.parameters);
+            emitWithPrefix(": ", node.type);
+        }
+
+        function shouldEmitBlockFunctionBodyOnSingleLine(body: Block) {
+            // We must emit a function body as a single-line body in the following case:
+            // * The body has NodeEmitFlags.SingleLine specified.
+
+            // We must emit a function body as a multi-line body in the following cases:
+            // * The body is explicitly marked as multi-line.
+            // * A non-synthesized body's start and end position are on different lines.
+            // * Any statement in the body starts on a new line.
+
+            if (getEmitFlags(body) & EmitFlags.SingleLine) {
+                return true;
+            }
+
+            if (body.multiLine) {
+                return false;
+            }
+
+            if (!nodeIsSynthesized(body) && !rangeIsOnSingleLine(body, currentSourceFile)) {
+                return false;
+            }
+
+            if (shouldWriteLeadingLineTerminator(body, body.statements, ListFormat.PreserveLines)
+                || shouldWriteClosingLineTerminator(body, body.statements, ListFormat.PreserveLines)) {
+                return false;
+            }
+
+            let previousStatement: Statement;
+            for (const statement of body.statements) {
+                if (shouldWriteSeparatingLineTerminator(previousStatement, statement, ListFormat.PreserveLines)) {
+                    return false;
+                }
+
+                previousStatement = statement;
+            }
+
+            return true;
+        }
+
+        function emitBlockFunctionBody(body: Block) {
+            write(" {");
+            increaseIndent();
+
+            const emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body)
+                ? emitBlockFunctionBodyOnSingleLine
+                : emitBlockFunctionBodyWorker;
+
+            emitBodyIndirect(body, body.statements, emitBlockFunctionBody);
+
+            decreaseIndent();
+            writeToken(SyntaxKind.CloseBraceToken, body.statements.end, body);
+        }
+
+        function emitBlockFunctionBodyOnSingleLine(body: Block) {
+            emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true);
+        }
+
+        function emitBlockFunctionBodyWorker(body: Block, emitBlockFunctionBodyOnSingleLine?: boolean) {
+            // Emit all the prologue directives (like "use strict").
+            const statementOffset = emitPrologueDirectives(body.statements, /*startWithNewLine*/ true);
+            const pos = writer.getTextPos();
+            emitHelpersIndirect(body);
+            if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) {
+                decreaseIndent();
+                emitList(body, body.statements, ListFormat.SingleLineFunctionBodyStatements);
+                increaseIndent();
+            }
+            else {
+                emitList(body, body.statements, ListFormat.MultiLineFunctionBodyStatements, statementOffset);
+            }
+        }
+
+        function emitClassDeclaration(node: ClassDeclaration) {
+            emitClassDeclarationOrExpression(node);
+        }
+
+        function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("class");
+            emitNodeWithPrefix(" ", node.name, emitIdentifierName);
+
+            const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+            if (indentedFlag) {
+                increaseIndent();
+            }
+
+            emitTypeParameters(node, node.typeParameters);
+            emitList(node, node.heritageClauses, ListFormat.ClassHeritageClauses);
+
+            pushNameGenerationScope();
+            write(" {");
+            emitList(node, node.members, ListFormat.ClassMembers);
+            write("}");
+            popNameGenerationScope();
+
+            if (indentedFlag) {
+                decreaseIndent();
+            }
+        }
+
+        function emitInterfaceDeclaration(node: InterfaceDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("interface ");
+            emit(node.name);
+            emitTypeParameters(node, node.typeParameters);
+            emitList(node, node.heritageClauses, ListFormat.HeritageClauses);
+            write(" {");
+            emitList(node, node.members, ListFormat.InterfaceMembers);
+            write("}");
+        }
+
+        function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {
+            emitDecorators(node, node.decorators);
+            emitModifiers(node, node.modifiers);
+            write("type ");
+            emit(node.name);
+            emitTypeParameters(node, node.typeParameters);
+            write(" = ");
+            emit(node.type);
+            write(";");
+        }
+
+        function emitEnumDeclaration(node: EnumDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("enum ");
+            emit(node.name);
+            pushNameGenerationScope();
+            write(" {");
+            emitList(node, node.members, ListFormat.EnumMembers);
+            write("}");
+            popNameGenerationScope();
+        }
+
+        function emitModuleDeclaration(node: ModuleDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
+            emit(node.name);
+
+            let body = node.body;
+            while (body.kind === SyntaxKind.ModuleDeclaration) {
+                write(".");
+                emit((<ModuleDeclaration>body).name);
+                body = (<ModuleDeclaration>body).body;
+            }
+
+            write(" ");
+            emit(body);
+        }
+
+        function emitModuleBlock(node: ModuleBlock) {
+            if (isEmptyBlock(node)) {
+                write("{ }");
+            }
+            else {
+                pushNameGenerationScope();
+                write("{");
+                increaseIndent();
+                emitBlockStatements(node);
+                write("}");
+                popNameGenerationScope();
+            }
+        }
+
+        function emitCaseBlock(node: CaseBlock) {
+            writeToken(SyntaxKind.OpenBraceToken, node.pos);
+            emitList(node, node.clauses, ListFormat.CaseBlockClauses);
+            writeToken(SyntaxKind.CloseBraceToken, node.clauses.end);
+        }
+
+        function emitImportEqualsDeclaration(node: ImportEqualsDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("import ");
+            emit(node.name);
+            write(" = ");
+            emitModuleReference(node.moduleReference);
+            write(";");
+        }
+
+        function emitModuleReference(node: ModuleReference) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        function emitImportDeclaration(node: ImportDeclaration) {
+            emitModifiers(node, node.modifiers);
+            write("import ");
+            if (node.importClause) {
+                emit(node.importClause);
+                write(" from ");
+            }
+            emitExpression(node.moduleSpecifier);
+            write(";");
+        }
+
+        function emitImportClause(node: ImportClause) {
+            emit(node.name);
+            if (node.name && node.namedBindings) {
+                write(", ");
+            }
+            emit(node.namedBindings);
+        }
+
+        function emitNamespaceImport(node: NamespaceImport) {
+            write("* as ");
+            emit(node.name);
+        }
+
+        function emitNamedImports(node: NamedImports) {
+            emitNamedImportsOrExports(node);
+        }
+
+        function emitImportSpecifier(node: ImportSpecifier) {
+            emitImportOrExportSpecifier(node);
+        }
+
+        function emitExportAssignment(node: ExportAssignment) {
+            write(node.isExportEquals ? "export = " : "export default ");
+            emitExpression(node.expression);
+            write(";");
+        }
+
+        function emitExportDeclaration(node: ExportDeclaration) {
+            write("export ");
+            if (node.exportClause) {
+                emit(node.exportClause);
+            }
+            else {
+                write("*");
+            }
+            if (node.moduleSpecifier) {
+                write(" from ");
+                emitExpression(node.moduleSpecifier);
+            }
+            write(";");
+        }
+
+        function emitNamedExports(node: NamedExports) {
+            emitNamedImportsOrExports(node);
+        }
+
+        function emitExportSpecifier(node: ExportSpecifier) {
+            emitImportOrExportSpecifier(node);
+        }
+
+        function emitNamedImportsOrExports(node: NamedImportsOrExports) {
+            write("{");
+            emitList(node, node.elements, ListFormat.NamedImportsOrExportsElements);
+            write("}");
+        }
+
+        function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
+            if (node.propertyName) {
+                emit(node.propertyName);
+                write(" as ");
+            }
+
+            emit(node.name);
+        }
+
+        //
+        // Module references
+        //
+
+        function emitExternalModuleReference(node: ExternalModuleReference) {
+            write("require(");
+            emitExpression(node.expression);
+            write(")");
+        }
+
+        //
+        // JSX
+        //
+
+        function emitJsxElement(node: JsxElement) {
+            emit(node.openingElement);
+            emitList(node, node.children, ListFormat.JsxElementChildren);
+            emit(node.closingElement);
+        }
+
+        function emitJsxSelfClosingElement(node: JsxSelfClosingElement) {
+            write("<");
+            emitJsxTagName(node.tagName);
+            write(" ");
+            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
+            write("/>");
+        }
+
+        function emitJsxOpeningElement(node: JsxOpeningElement) {
+            write("<");
+            emitJsxTagName(node.tagName);
+            writeIfAny(node.attributes, " ");
+            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
+            write(">");
+        }
+
+        function emitJsxText(node: JsxText) {
+            writer.writeLiteral(getTextOfNode(node, /*includeTrivia*/ true));
+        }
+
+        function emitJsxClosingElement(node: JsxClosingElement) {
+            write("</");
+            emitJsxTagName(node.tagName);
+            write(">");
+        }
+
+        function emitJsxAttribute(node: JsxAttribute) {
+            emit(node.name);
+            emitWithPrefix("=", node.initializer);
+        }
+
+        function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {
+            write("{...");
+            emitExpression(node.expression);
+            write("}");
+        }
+
+        function emitJsxExpression(node: JsxExpression) {
+            if (node.expression) {
+                write("{");
+                if (node.dotDotDotToken) {
+                    write("...");
+                }
+                emitExpression(node.expression);
+                write("}");
+            }
+        }
+
+        function emitJsxTagName(node: JsxTagNameExpression) {
+            if (node.kind === SyntaxKind.Identifier) {
+                emitExpression(<Identifier>node);
+            }
+            else {
+                emit(node);
+            }
+        }
+
+        //
+        // Clauses
+        //
+
+        function emitCaseClause(node: CaseClause) {
+            write("case ");
+            emitExpression(node.expression);
+            write(":");
+
+            emitCaseOrDefaultClauseStatements(node, node.statements);
+        }
+
+        function emitDefaultClause(node: DefaultClause) {
+            write("default:");
+            emitCaseOrDefaultClauseStatements(node, node.statements);
+        }
+
+        function emitCaseOrDefaultClauseStatements(parentNode: Node, statements: NodeArray<Statement>) {
+            const emitAsSingleStatement =
+                statements.length === 1 &&
+                (
+                    // treat synthesized nodes as located on the same line for emit purposes
+                    nodeIsSynthesized(parentNode) ||
+                    nodeIsSynthesized(statements[0]) ||
+                    rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)
+                );
+
+            if (emitAsSingleStatement) {
+                write(" ");
+                emit(statements[0]);
+            }
+            else {
+                emitList(parentNode, statements, ListFormat.CaseOrDefaultClauseStatements);
+            }
+        }
+
+        function emitHeritageClause(node: HeritageClause) {
+            write(" ");
+            writeTokenText(node.token);
+            write(" ");
+            emitList(node, node.types, ListFormat.HeritageClauseTypes);
+        }
+
+        function emitCatchClause(node: CatchClause) {
+            writeLine();
+            const openParenPos = writeToken(SyntaxKind.CatchKeyword, node.pos);
+            write(" ");
+            writeToken(SyntaxKind.OpenParenToken, openParenPos);
+            emit(node.variableDeclaration);
+            writeToken(SyntaxKind.CloseParenToken, node.variableDeclaration ? node.variableDeclaration.end : openParenPos);
+            write(" ");
+            emit(node.block);
+        }
+
+        //
+        // Property assignments
+        //
+
+        function emitPropertyAssignment(node: PropertyAssignment) {
+            emit(node.name);
+            write(": ");
+            // This is to ensure that we emit comment in the following case:
+            //      For example:
+            //          obj = {
+            //              id: /*comment1*/ ()=>void
+            //          }
+            // "comment1" is not considered to be leading comment for node.initializer
+            // but rather a trailing comment on the previous node.
+            const initializer = node.initializer;
+            if (emitTrailingCommentsOfPosition && (getEmitFlags(initializer) & EmitFlags.NoLeadingComments) === 0) {
+                const commentRange = getCommentRange(initializer);
+                emitTrailingCommentsOfPosition(commentRange.pos);
+            }
+            emitExpression(initializer);
+        }
+
+        function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {
+            emit(node.name);
+            if (node.objectAssignmentInitializer) {
+                write(" = ");
+                emitExpression(node.objectAssignmentInitializer);
+            }
+        }
+
+        function emitSpreadAssignment(node: SpreadAssignment) {
+            if (node.expression) {
+                write("...");
+                emitExpression(node.expression);
+            }
+        }
+
+        //
+        // Enum
+        //
+
+        function emitEnumMember(node: EnumMember) {
+            emit(node.name);
+            emitExpressionWithPrefix(" = ", node.initializer);
+        }
+
+        //
+        // Top-level nodes
+        //
+
+        function emitSourceFile(node: SourceFile) {
+            writeLine();
+            emitShebang();
+            emitBodyIndirect(node, node.statements, emitSourceFileWorker);
+        }
+
+        function emitSourceFileWorker(node: SourceFile) {
+            const statements = node.statements;
+            const statementOffset = emitPrologueDirectives(statements);
+            pushNameGenerationScope();
+            emitHelpersIndirect(node);
+            emitList(node, statements, ListFormat.MultiLine, statementOffset);
+            popNameGenerationScope();
+        }
+
+        // Transformation nodes
+
+        function emitPartiallyEmittedExpression(node: PartiallyEmittedExpression) {
+            emitExpression(node.expression);
+        }
+
+        /**
+         * Emits any prologue directives at the start of a Statement list, returning the
+         * number of prologue directives written to the output.
+         */
+        function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean): number {
+            for (let i = 0; i < statements.length; i++) {
+                if (isPrologueDirective(statements[i])) {
+                    if (startWithNewLine || i > 0) {
+                        writeLine();
+                    }
+                    emit(statements[i]);
+                }
+                else {
+                    // return index of the first non prologue directive
+                    return i;
+                }
+            }
+
+            return statements.length;
+        }
+
+        //
+        // Helpers
+        //
+
+        function emitShebang() {
+            const shebang = getShebang(currentSourceFile.text);
+            if (shebang) {
+                write(shebang);
+                writeLine();
+            }
+        }
+
+        function emitModifiers(node: Node, modifiers: NodeArray<Modifier>) {
+            if (modifiers && modifiers.length) {
+                emitList(node, modifiers, ListFormat.Modifiers);
+                write(" ");
+            }
+        }
+
+        function emitWithPrefix(prefix: string, node: Node) {
+            emitNodeWithPrefix(prefix, node, emit);
+        }
+
+        function emitExpressionWithPrefix(prefix: string, node: Node) {
+            emitNodeWithPrefix(prefix, node, emitExpression);
+        }
+
+        function emitNodeWithPrefix(prefix: string, node: Node, emit: (node: Node) => void) {
+            if (node) {
+                write(prefix);
+                emit(node);
+            }
+        }
+
+        function emitWithSuffix(node: Node, suffix: string) {
+            if (node) {
+                emit(node);
+                write(suffix);
+            }
+        }
+
+        function emitEmbeddedStatement(parent: Node, node: Statement) {
+            if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
+                write(" ");
+                emit(node);
+            }
+            else {
+                writeLine();
+                increaseIndent();
+                emit(node);
+                decreaseIndent();
+            }
+        }
+
+        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator>) {
+            emitList(parentNode, decorators, ListFormat.Decorators);
+        }
+
+        function emitTypeArguments(parentNode: Node, typeArguments: NodeArray<TypeNode>) {
+            emitList(parentNode, typeArguments, ListFormat.TypeArguments);
+        }
+
+        function emitTypeParameters(parentNode: Node, typeParameters: NodeArray<TypeParameterDeclaration>) {
+            emitList(parentNode, typeParameters, ListFormat.TypeParameters);
+        }
+
+        function emitParameters(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            emitList(parentNode, parameters, ListFormat.Parameters);
+        }
+
+        function emitParametersForArrow(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            if (parameters &&
+                parameters.length === 1 &&
+                parameters[0].type === undefined &&
+                parameters[0].pos === parentNode.pos) {
+                emit(parameters[0]);
+            }
+            else {
+                emitParameters(parentNode, parameters);
+            }
+        }
+
+        function emitParametersForIndexSignature(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
+            emitList(parentNode, parameters, ListFormat.IndexSignatureParameters);
+        }
+
+        function emitList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
+            emitNodeList(emit, parentNode, children, format, start, count);
+        }
+
+        function emitExpressionList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
+            emitNodeList(emitExpression, parentNode, children, format, start, count);
+        }
+
+        function emitNodeList(emit: (node: Node) => void, parentNode: Node, children: NodeArray<Node>, format: ListFormat, start = 0, count = children ? children.length - start : 0) {
+            const isUndefined = children === undefined;
+            if (isUndefined && format & ListFormat.OptionalIfUndefined) {
+                return;
+            }
+
+            const isEmpty = isUndefined || children.length === 0 || start >= children.length || count === 0;
+            if (isEmpty && format & ListFormat.OptionalIfEmpty) {
+                return;
+            }
+
+            if (format & ListFormat.BracketsMask) {
+                write(getOpeningBracket(format));
+            }
+
+            if (isEmpty) {
+                // Write a line terminator if the parent node was multi-line
+                if (format & ListFormat.MultiLine) {
+                    writeLine();
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+            }
+            else {
+                // Write the opening line terminator or leading whitespace.
+                const mayEmitInterveningComments = (format & ListFormat.NoInterveningComments) === 0;
+                let shouldEmitInterveningComments = mayEmitInterveningComments;
+                if (shouldWriteLeadingLineTerminator(parentNode, children, format)) {
+                    writeLine();
+                    shouldEmitInterveningComments = false;
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+
+                // Increase the indent, if requested.
+                if (format & ListFormat.Indented) {
+                    increaseIndent();
+                }
+
+                // Emit each child.
+                let previousSibling: Node;
+                let shouldDecreaseIndentAfterEmit: boolean;
+                const delimiter = getDelimiter(format);
+                for (let i = 0; i < count; i++) {
+                    const child = children[start + i];
+
+                    // Write the delimiter if this is not the first node.
+                    if (previousSibling) {
+                        write(delimiter);
+
+                        // Write either a line terminator or whitespace to separate the elements.
+                        if (shouldWriteSeparatingLineTerminator(previousSibling, child, format)) {
+                            // If a synthesized node in a single-line list starts on a new
+                            // line, we should increase the indent.
+                            if ((format & (ListFormat.LinesMask | ListFormat.Indented)) === ListFormat.SingleLine) {
+                                increaseIndent();
+                                shouldDecreaseIndentAfterEmit = true;
+                            }
+
+                            writeLine();
+                            shouldEmitInterveningComments = false;
+                        }
+                        else if (previousSibling && format & ListFormat.SpaceBetweenSiblings) {
+                            write(" ");
+                        }
+                    }
+
+                    // Emit this child.
+                    if (shouldEmitInterveningComments) {
+                        if (emitTrailingCommentsOfPosition) {
+                            const commentRange = getCommentRange(child);
+                            emitTrailingCommentsOfPosition(commentRange.pos);
+                        }
+                    }
+                    else {
+                        shouldEmitInterveningComments = mayEmitInterveningComments;
+                    }
+
+                    emit(child);
+
+                    if (shouldDecreaseIndentAfterEmit) {
+                        decreaseIndent();
+                        shouldDecreaseIndentAfterEmit = false;
+                    }
+
+                    previousSibling = child;
+                }
+
+                // Write a trailing comma, if requested.
+                const hasTrailingComma = (format & ListFormat.AllowTrailingComma) && children.hasTrailingComma;
+                if (format & ListFormat.CommaDelimited && hasTrailingComma) {
+                    write(",");
+                }
+
+                // Decrease the indent, if requested.
+                if (format & ListFormat.Indented) {
+                    decreaseIndent();
+                }
+
+                // Write the closing line terminator or closing whitespace.
+                if (shouldWriteClosingLineTerminator(parentNode, children, format)) {
+                    writeLine();
+                }
+                else if (format & ListFormat.SpaceBetweenBraces) {
+                    write(" ");
+                }
+            }
+
+            if (format & ListFormat.BracketsMask) {
+                write(getClosingBracket(format));
+            }
+        }
+
+        function write(s: string) {
+            writer.write(s);
+        }
+
+        function writeLine() {
+            writer.writeLine();
+        }
+
+        function increaseIndent() {
+            writer.increaseIndent();
+        }
+
+        function decreaseIndent() {
+            writer.decreaseIndent();
+        }
+
+        function writeIfAny(nodes: NodeArray<Node>, text: string) {
+            if (some(nodes)) {
+                write(text);
+            }
+        }
+
+        function writeIfPresent(node: Node, text: string) {
+            if (node) {
+                write(text);
+            }
+        }
+
+        function writeToken(token: SyntaxKind, pos: number, contextNode?: Node) {
+            return onEmitSourceMapOfToken
+                ? onEmitSourceMapOfToken(contextNode, token, pos, writeTokenText)
+                : writeTokenText(token, pos);
+        }
+
+        function writeTokenText(token: SyntaxKind, pos?: number) {
+            const tokenString = tokenToString(token);
+            write(tokenString);
+            return pos < 0 ? pos : pos + tokenString.length;
+        }
+
+        function writeLineOrSpace(node: Node) {
+            if (getEmitFlags(node) & EmitFlags.SingleLine) {
+                write(" ");
+            }
+            else {
+                writeLine();
+            }
+        }
+
+        function writeLines(text: string): void {
+            const lines = text.split(/\r\n?|\n/g);
+            const indentation = guessIndentation(lines);
+            for (let i = 0; i < lines.length; i++) {
+                const line = indentation ? lines[i].slice(indentation) : lines[i];
+                if (line.length) {
+                    writeLine();
+                    write(line);
+                    writeLine();
+                }
+            }
+        }
+
+        function guessIndentation(lines: string[]) {
+            let indentation: number;
+            for (const line of lines) {
+                for (let i = 0; i < line.length && (indentation === undefined || i < indentation); i++) {
+                    if (!isWhiteSpace(line.charCodeAt(i))) {
+                        if (indentation === undefined || i < indentation) {
+                            indentation = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            return indentation;
+        }
+
+        function increaseIndentIf(value: boolean, valueToWriteWhenNotIndenting?: string) {
+            if (value) {
+                increaseIndent();
+                writeLine();
+            }
+            else if (valueToWriteWhenNotIndenting) {
+                write(valueToWriteWhenNotIndenting);
+            }
+        }
+
+        // Helper function to decrease the indent if we previously indented.  Allows multiple
+        // previous indent values to be considered at a time.  This also allows caller to just
+        // call this once, passing in all their appropriate indent values, instead of needing
+        // to call this helper function multiple times.
+        function decreaseIndentIf(value1: boolean, value2?: boolean) {
+            if (value1) {
+                decreaseIndent();
+            }
+            if (value2) {
+                decreaseIndent();
+            }
+        }
+
+        function shouldWriteLeadingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return true;
+            }
+
+            if (format & ListFormat.PreserveLines) {
+                if (format & ListFormat.PreferNewLine) {
+                    return true;
+                }
+
+                const firstChild = children[0];
+                if (firstChild === undefined) {
+                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
+                }
+                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(firstChild)) {
+                    return synthesizedNodeStartsOnNewLine(firstChild, format);
+                }
+                else {
+                    return !rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+
+        function shouldWriteSeparatingLineTerminator(previousNode: Node, nextNode: Node, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return true;
+            }
+            else if (format & ListFormat.PreserveLines) {
+                if (previousNode === undefined || nextNode === undefined) {
+                    return false;
+                }
+                else if (nodeIsSynthesized(previousNode) || nodeIsSynthesized(nextNode)) {
+                    return synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format);
+                }
+                else {
+                    return !rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile);
+                }
+            }
+            else {
+                return nextNode.startsOnNewLine;
+            }
+        }
+
+        function shouldWriteClosingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
+            if (format & ListFormat.MultiLine) {
+                return (format & ListFormat.NoTrailingNewLine) === 0;
+            }
+            else if (format & ListFormat.PreserveLines) {
+                if (format & ListFormat.PreferNewLine) {
+                    return true;
+                }
+
+                const lastChild = lastOrUndefined(children);
+                if (lastChild === undefined) {
+                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
+                }
+                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(lastChild)) {
+                    return synthesizedNodeStartsOnNewLine(lastChild, format);
+                }
+                else {
+                    return !rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+
+        function synthesizedNodeStartsOnNewLine(node: Node, format?: ListFormat) {
+            if (nodeIsSynthesized(node)) {
+                const startsOnNewLine = node.startsOnNewLine;
+                if (startsOnNewLine === undefined) {
+                    return (format & ListFormat.PreferNewLine) !== 0;
+                }
+
+                return startsOnNewLine;
+            }
+
+            return (format & ListFormat.PreferNewLine) !== 0;
+        }
+
+        function needsIndentation(parent: Node, node1: Node, node2: Node): boolean {
+            parent = skipSynthesizedParentheses(parent);
+            node1 = skipSynthesizedParentheses(node1);
+            node2 = skipSynthesizedParentheses(node2);
+
+            // Always use a newline for synthesized code if the synthesizer desires it.
+            if (node2.startsOnNewLine) {
+                return true;
+            }
+
+            return !nodeIsSynthesized(parent)
+                && !nodeIsSynthesized(node1)
+                && !nodeIsSynthesized(node2)
+                && !rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile);
+        }
+
+        function isSingleLineEmptyBlock(block: Block) {
+            return !block.multiLine
+                && isEmptyBlock(block);
+        }
+
+        function isEmptyBlock(block: BlockLike) {
+            return block.statements.length === 0
+                && rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
+        }
+
+        function skipSynthesizedParentheses(node: Node) {
+            while (node.kind === SyntaxKind.ParenthesizedExpression && nodeIsSynthesized(node)) {
+                node = (<ParenthesizedExpression>node).expression;
+            }
+
+            return node;
+        }
+
+        function getTextOfNode(node: Node, includeTrivia?: boolean): string {
+            if (isGeneratedIdentifier(node)) {
+                return generateName(node);
+            }
+            else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
+                return unescapeIdentifier(node.text);
+            }
+            else if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
+                return getTextOfNode((<StringLiteral>node).textSourceNode, includeTrivia);
+            }
+            else if (isLiteralExpression(node) && (nodeIsSynthesized(node) || !node.parent)) {
+                return node.text;
+            }
+
+            return getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia);
+        }
+
+        function getLiteralTextOfNode(node: LiteralLikeNode): string {
+            if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
+                const textSourceNode = (<StringLiteral>node).textSourceNode;
+                if (isIdentifier(textSourceNode)) {
+                    return "\"" + escapeNonAsciiCharacters(escapeString(getTextOfNode(textSourceNode))) + "\"";
+                }
+                else {
+                    return getLiteralTextOfNode(textSourceNode);
+                }
+            }
+
+            return getLiteralText(node, currentSourceFile, languageVersion);
+        }
+
+        /**
+         * Push a new name generation scope.
+         */
+        function pushNameGenerationScope() {
+            tempFlagsStack.push(tempFlags);
+            tempFlags = 0;
+        }
+
+        /**
+         * Pop the current name generation scope.
+         */
+        function popNameGenerationScope() {
+            tempFlags = tempFlagsStack.pop();
+        }
+
+        /**
+         * Generate the text for a generated identifier.
+         */
+        function generateName(name: GeneratedIdentifier) {
+            if (name.autoGenerateKind === GeneratedIdentifierKind.Node) {
+                // Node names generate unique names based on their original node
+                // and are cached based on that node's id.
+                const node = getNodeForGeneratedName(name);
+                return generateNameCached(node, getTextOfNode);
+            }
+            else {
+                // Auto, Loop, and Unique names are cached based on their unique
+                // autoGenerateId.
+                const autoGenerateId = name.autoGenerateId;
+                return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = unescapeIdentifier(makeName(name)));
+            }
+        }
+
+        function generateNameCached(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            const nodeId = getNodeId(node);
+            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node, getTextOfNode)));
+        }
+
+        /**
+         * Returns a value indicating whether a name is unique globally, within the current file,
+         * or within the NameGenerator.
+         */
+        function isUniqueName(name: string): boolean {
+            return !(hasGlobalName && hasGlobalName(name))
+                && !currentSourceFile.identifiers.has(name)
+                && !generatedNames.has(name);
+        }
+
+        /**
+         * Returns a value indicating whether a name is unique within a container.
+         */
+        function isUniqueLocalName(name: string, container: Node): boolean {
+            for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
+                if (node.locals) {
+                    const local = node.locals.get(name);
+                    // We conservatively include alias symbols to cover cases where they're emitted as locals
+                    if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Return the next available name in the pattern _a ... _z, _0, _1, ...
+         * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.
+         * Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
+         */
+        function makeTempVariableName(flags: TempFlags): string {
+            if (flags && !(tempFlags & flags)) {
+                const name = flags === TempFlags._i ? "_i" : "_n";
+                if (isUniqueName(name)) {
+                    tempFlags |= flags;
+                    return name;
+                }
+            }
+            while (true) {
+                const count = tempFlags & TempFlags.CountMask;
+                tempFlags++;
+                // Skip over 'i' and 'n'
+                if (count !== 8 && count !== 13) {
+                    const name = count < 26
+                        ? "_" + String.fromCharCode(CharacterCodes.a + count)
+                        : "_" + (count - 26);
+                    if (isUniqueName(name)) {
+                        return name;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Generate a name that is unique within the current file and doesn't conflict with any names
+         * in global scope. The name is formed by adding an '_n' suffix to the specified base name,
+         * where n is a positive integer. Note that names generated by makeTempVariableName and
+         * makeUniqueName are guaranteed to never conflict.
+         */
+        function makeUniqueName(baseName: string): string {
+            // Find the first unique 'name_n', where n is a positive number
+            if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {
+                baseName += "_";
+            }
+            let i = 1;
+            while (true) {
+                const generatedName = baseName + i;
+                if (isUniqueName(generatedName)) {
+                    generatedNames.set(generatedName, generatedName);
+                    return generatedName;
+                }
+                i++;
+            }
+        }
+
+        /**
+         * Generates a unique name for a ModuleDeclaration or EnumDeclaration.
+         */
+        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            const name = getTextOfNode(node.name);
+            // Use module/enum name itself if it is unique, otherwise make a unique variation
+            return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
+        }
+
+        /**
+         * Generates a unique name for an ImportDeclaration or ExportDeclaration.
+         */
+        function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {
+            const expr = getExternalModuleName(node);
+            const baseName = expr.kind === SyntaxKind.StringLiteral ?
+                escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";
+            return makeUniqueName(baseName);
+        }
+
+        /**
+         * Generates a unique name for a default export.
+         */
+        function generateNameForExportDefault() {
+            return makeUniqueName("default");
+        }
+
+        /**
+         * Generates a unique name for a class expression.
+         */
+        function generateNameForClassExpression() {
+            return makeUniqueName("class");
+        }
+
+        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+            if (isIdentifier(node.name)) {
+                return generateNameCached(node.name, getTextOfNode);
+            }
+            return makeTempVariableName(TempFlags.Auto);
+        }
+
+        /**
+         * Generates a unique name from a node.
+         */
+        function generateNameForNode(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string): string {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    return makeUniqueName(getTextOfNode(node));
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node, getTextOfNode);
+                case SyntaxKind.ImportDeclaration:
+                case SyntaxKind.ExportDeclaration:
+                    return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.ExportAssignment:
+                    return generateNameForExportDefault();
+                case SyntaxKind.ClassExpression:
+                    return generateNameForClassExpression();
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node, getTextOfNode);
+                default:
+                    return makeTempVariableName(TempFlags.Auto);
+            }
+        }
+
+        /**
+         * Generates a unique identifier for a node.
+         */
+        function makeName(name: GeneratedIdentifier) {
+            switch (name.autoGenerateKind) {
+                case GeneratedIdentifierKind.Auto:
+                    return makeTempVariableName(TempFlags.Auto);
+                case GeneratedIdentifierKind.Loop:
+                    return makeTempVariableName(TempFlags._i);
+                case GeneratedIdentifierKind.Unique:
+                    return makeUniqueName(name.text);
+            }
+
+            Debug.fail("Unsupported GeneratedIdentifierKind.");
+        }
+
+        /**
+         * Gets the node from which a name should be generated.
+         */
+        function getNodeForGeneratedName(name: GeneratedIdentifier) {
+            const autoGenerateId = name.autoGenerateId;
+            let node = name as Node;
+            let original = node.original;
+            while (original) {
+                node = original;
+
+                // if "node" is a different generated name (having a different
+                // "autoGenerateId"), use it and stop traversing.
+                if (isIdentifier(node)
+                    && node.autoGenerateKind === GeneratedIdentifierKind.Node
+                    && node.autoGenerateId !== autoGenerateId) {
+                    break;
+                }
+
+                original = node.original;
+            }
+
+            // otherwise, return the original node for the source;
+            return node;
+        }
+    }
+
+    function createDelimiterMap() {
+        const delimiters: string[] = [];
+        delimiters[ListFormat.None] = "";
+        delimiters[ListFormat.CommaDelimited] = ",";
+        delimiters[ListFormat.BarDelimited] = " |";
+        delimiters[ListFormat.AmpersandDelimited] = " &";
+        return delimiters;
+    }
+
+    function getDelimiter(format: ListFormat) {
+        return delimiters[format & ListFormat.DelimitersMask];
+    }
+
+    function createBracketsMap() {
+        const brackets: string[][] = [];
+        brackets[ListFormat.Braces] = ["{", "}"];
+        brackets[ListFormat.Parenthesis] = ["(", ")"];
+        brackets[ListFormat.AngleBrackets] = ["<", ">"];
+        brackets[ListFormat.SquareBrackets] = ["[", "]"];
+        return brackets;
+    }
+
+    function getOpeningBracket(format: ListFormat) {
+        return brackets[format & ListFormat.BracketsMask][0];
+    }
+
+    function getClosingBracket(format: ListFormat) {
+        return brackets[format & ListFormat.BracketsMask][1];
+    }
+
+    // Flags enum to track count of temp variables and a few dedicated names
+    const enum TempFlags {
+        Auto      = 0x00000000,  // No preferred name
+        CountMask = 0x0FFFFFFF,  // Temp variable counter
+        _i        = 0x10000000,  // Use/preference flag for '_i'
+    }
+
+    const enum ListFormat {
+        None = 0,
+
+        // Line separators
+        SingleLine = 0,                 // Prints the list on a single line (default).
+        MultiLine = 1 << 0,             // Prints the list on multiple lines.
+        PreserveLines = 1 << 1,         // Prints the list using line preservation if possible.
+        LinesMask = SingleLine | MultiLine | PreserveLines,
+
+        // Delimiters
+        NotDelimited = 0,               // There is no delimiter between list items (default).
+        BarDelimited = 1 << 2,          // Each list item is space-and-bar (" |") delimited.
+        AmpersandDelimited = 1 << 3,    // Each list item is space-and-ampersand (" &") delimited.
+        CommaDelimited = 1 << 4,        // Each list item is comma (",") delimited.
+        DelimitersMask = BarDelimited | AmpersandDelimited | CommaDelimited,
+
+        AllowTrailingComma = 1 << 5,    // Write a trailing comma (",") if present.
+
+        // Whitespace
+        Indented = 1 << 6,              // The list should be indented.
+        SpaceBetweenBraces = 1 << 7,    // Inserts a space after the opening brace and before the closing brace.
+        SpaceBetweenSiblings = 1 << 8,  // Inserts a space between each sibling node.
+
+        // Brackets/Braces
+        Braces = 1 << 9,                // The list is surrounded by "{" and "}".
+        Parenthesis = 1 << 10,          // The list is surrounded by "(" and ")".
+        AngleBrackets = 1 << 11,        // The list is surrounded by "<" and ">".
+        SquareBrackets = 1 << 12,       // The list is surrounded by "[" and "]".
+        BracketsMask = Braces | Parenthesis | AngleBrackets | SquareBrackets,
+
+        OptionalIfUndefined = 1 << 13,  // Do not emit brackets if the list is undefined.
+        OptionalIfEmpty = 1 << 14,      // Do not emit brackets if the list is empty.
+        Optional = OptionalIfUndefined | OptionalIfEmpty,
+
+        // Other
+        PreferNewLine = 1 << 15,        // Prefer adding a LineTerminator between synthesized nodes.
+        NoTrailingNewLine = 1 << 16,    // Do not emit a trailing NewLine for a MultiLine list.
+        NoInterveningComments = 1 << 17, // Do not emit comments between each node
+
+        // Precomputed Formats
+        Modifiers = SingleLine | SpaceBetweenSiblings,
+        HeritageClauses = SingleLine | SpaceBetweenSiblings,
+        TypeLiteralMembers = MultiLine | Indented,
+        TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented,
+        UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine,
+        IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine,
+        ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings,
+        ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings,
+        ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces,
+        ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
+        CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
+        NewExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis | OptionalIfUndefined,
+        TemplateExpressionSpans = SingleLine | NoInterveningComments,
+        SingleLineBlockStatements = SpaceBetweenBraces | SpaceBetweenSiblings | SingleLine,
+        MultiLineBlockStatements = Indented | MultiLine,
+        VariableDeclarationList = CommaDelimited | SpaceBetweenSiblings | SingleLine,
+        SingleLineFunctionBodyStatements = SingleLine | SpaceBetweenSiblings | SpaceBetweenBraces,
+        MultiLineFunctionBodyStatements = MultiLine,
+        ClassHeritageClauses = SingleLine | SpaceBetweenSiblings,
+        ClassMembers = Indented | MultiLine,
+        InterfaceMembers = Indented | MultiLine,
+        EnumMembers = CommaDelimited | Indented | MultiLine,
+        CaseBlockClauses = Indented | MultiLine,
+        NamedImportsOrExportsElements = CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | SingleLine | SpaceBetweenBraces,
+        JsxElementChildren = SingleLine | NoInterveningComments,
+        JsxElementAttributes = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
+        CaseOrDefaultClauseStatements = Indented | MultiLine | NoTrailingNewLine | OptionalIfEmpty,
+        HeritageClauseTypes = CommaDelimited | SpaceBetweenSiblings | SingleLine,
+        SourceFileStatements = MultiLine | NoTrailingNewLine,
+        Decorators = MultiLine | Optional,
+        TypeArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
+        TypeParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
+        Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis,
+        IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
+    }
 }
\ No newline at end of file
diff --git a/src/compiler/printer.ts b/src/compiler/printer.ts
deleted file mode 100644
index 9ae824dac67..00000000000
--- a/src/compiler/printer.ts
+++ /dev/null
@@ -1,2659 +0,0 @@
-/// <reference path="checker.ts"/>
-
-namespace ts {
-    // Flags enum to track count of temp variables and a few dedicated names
-    const enum TempFlags {
-        Auto      = 0x00000000,  // No preferred name
-        CountMask = 0x0FFFFFFF,  // Temp variable counter
-        _i        = 0x10000000,  // Use/preference flag for '_i'
-    }
-
-    const delimiters = createDelimiterMap();
-    const brackets = createBracketsMap();
-
-    export function createPrinter(writer: EmitTextWriter, compilerOptions: CompilerOptions, printerOptions: PrinterOptions = {}): Printer {
-        const languageVersion = getEmitScriptTarget(compilerOptions);
-        const moduleKind = getEmitModuleKind(compilerOptions);
-        const {
-            hasGlobalName,
-            onEmitSourceMapOfNode,
-            onEmitSourceMapOfToken,
-            onEmitCommentsOfNode,
-            onEmitDetachedCommentsOfNode,
-            onEmitTrailingCommentsOfPosition,
-            onEmitNode,
-            onEmitHelpers,
-            onSetSourceFile,
-            onSubstituteNode,
-        } = printerOptions;
-        const {
-            write,
-            writeLine,
-            increaseIndent,
-            decreaseIndent
-        } = writer;
-
-        let currentSourceFile: SourceFile;
-        let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
-        let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
-        let generatedNames: Map<string>; // Set of names generated by the NameGenerator.
-        let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
-        let tempFlags: TempFlags; // TempFlags for the current name generation scope.
-
-        return {
-            printNode,
-            printFile,
-            printBundle
-        };
-
-        function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile) {
-            print(hint, node, sourceFile);
-            resetGeneratedNames();
-        }
-
-        function printBundle(bundle: Bundle) {
-            if (moduleKind) {
-                emitHelpersIndirect(bundle);
-            }
-            for (const sourceFile of bundle.sourceFiles) {
-                print(EmitHint.SourceFile, sourceFile, sourceFile);
-            }
-            resetGeneratedNames();
-        }
-
-        function printFile(sourceFile: SourceFile) {
-            print(EmitHint.SourceFile, sourceFile, sourceFile);
-            resetGeneratedNames();
-        }
-
-        function print(hint: EmitHint, node: Node, sourceFile: SourceFile) {
-            setSourceFile(sourceFile);
-            pipelineEmitWithNotification(hint, node);
-        }
-
-        function setSourceFile(sourceFile: SourceFile) {
-            currentSourceFile = sourceFile;
-
-            if (onSetSourceFile) {
-                onSetSourceFile(sourceFile);
-            }
-        }
-
-        function emit(node: Node, hint = EmitHint.Unspecified) {
-            pipelineEmitWithNotification(hint, node);
-        }
-
-        function emitIdentifierName(node: Identifier) {
-            pipelineEmitWithNotification(EmitHint.IdentifierName, node);
-        }
-
-        function emitExpression(node: Expression) {
-            pipelineEmitWithNotification(EmitHint.Expression, node);
-        }
-
-        function pipelineEmitWithNotification(hint: EmitHint, node: Node) {
-            if (onEmitNode) {
-                onEmitNode(hint, node, pipelineEmitWithComments);
-            }
-            else {
-                pipelineEmitWithComments(hint, node);
-            }
-        }
-
-        function pipelineEmitWithComments(hint: EmitHint, node: Node) {
-            if (onEmitCommentsOfNode && hint !== EmitHint.SourceFile) {
-                onEmitCommentsOfNode(hint, node, pipelineEmitWithSourceMap);
-            }
-            else {
-                pipelineEmitWithSourceMap(hint, node);
-            }
-        }
-
-        function pipelineEmitWithSourceMap(hint: EmitHint, node: Node) {
-            if (onEmitSourceMapOfNode && hint !== EmitHint.SourceFile && hint !== EmitHint.IdentifierName) {
-                onEmitSourceMapOfNode(hint, node, pipelineEmitWithSubstitution);
-            }
-            else {
-                pipelineEmitWithSubstitution(hint, node);
-            }
-        }
-
-        function pipelineEmitWithSubstitution(hint: EmitHint, node: Node) {
-            if (onSubstituteNode) {
-                onSubstituteNode(hint, node, pipelineEmitWithHint);
-            }
-            else {
-                pipelineEmitWithHint(hint, node);
-            }
-        }
-
-        function pipelineEmitWithHint(hint: EmitHint, node: Node): void {
-            switch (hint) {
-                case EmitHint.SourceFile: return pipelineEmitSourceFile(node);
-                case EmitHint.IdentifierName: return pipelineEmitIdentifierName(node);
-                case EmitHint.Expression: return pipelineEmitExpression(node);
-                case EmitHint.Unspecified: return pipelineEmitUnspecified(node);
-            }
-        }
-
-        function pipelineEmitSourceFile(node: Node): void {
-            Debug.assertNode(node, isSourceFile);
-            emitSourceFile(<SourceFile>node);
-        }
-
-        function pipelineEmitIdentifierName(node: Node): void {
-            Debug.assertNode(node, isIdentifier);
-            emitIdentifier(<Identifier>node);
-        }
-
-        function pipelineEmitUnspecified(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Pseudo-literals
-                case SyntaxKind.TemplateHead:
-                case SyntaxKind.TemplateMiddle:
-                case SyntaxKind.TemplateTail:
-                    return emitLiteral(<LiteralExpression>node);
-
-                // Identifiers
-                case SyntaxKind.Identifier:
-                    return emitIdentifier(<Identifier>node);
-
-                // Reserved words
-                case SyntaxKind.ConstKeyword:
-                case SyntaxKind.DefaultKeyword:
-                case SyntaxKind.ExportKeyword:
-                case SyntaxKind.VoidKeyword:
-
-                // Strict mode reserved words
-                case SyntaxKind.PrivateKeyword:
-                case SyntaxKind.ProtectedKeyword:
-                case SyntaxKind.PublicKeyword:
-                case SyntaxKind.StaticKeyword:
-
-                // Contextual keywords
-                case SyntaxKind.AbstractKeyword:
-                case SyntaxKind.AsKeyword:
-                case SyntaxKind.AnyKeyword:
-                case SyntaxKind.AsyncKeyword:
-                case SyntaxKind.AwaitKeyword:
-                case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.ConstructorKeyword:
-                case SyntaxKind.DeclareKeyword:
-                case SyntaxKind.GetKeyword:
-                case SyntaxKind.IsKeyword:
-                case SyntaxKind.ModuleKeyword:
-                case SyntaxKind.NamespaceKeyword:
-                case SyntaxKind.NeverKeyword:
-                case SyntaxKind.ReadonlyKeyword:
-                case SyntaxKind.RequireKeyword:
-                case SyntaxKind.NumberKeyword:
-                case SyntaxKind.SetKeyword:
-                case SyntaxKind.StringKeyword:
-                case SyntaxKind.SymbolKeyword:
-                case SyntaxKind.TypeKeyword:
-                case SyntaxKind.UndefinedKeyword:
-                case SyntaxKind.FromKeyword:
-                case SyntaxKind.GlobalKeyword:
-                case SyntaxKind.OfKeyword:
-                    writeTokenText(kind);
-                    return;
-
-                // Parse tree nodes
-
-                // Names
-                case SyntaxKind.QualifiedName:
-                    return emitQualifiedName(<QualifiedName>node);
-                case SyntaxKind.ComputedPropertyName:
-                    return emitComputedPropertyName(<ComputedPropertyName>node);
-
-                // Signature elements
-                case SyntaxKind.TypeParameter:
-                    return emitTypeParameter(<TypeParameterDeclaration>node);
-                case SyntaxKind.Parameter:
-                    return emitParameter(<ParameterDeclaration>node);
-                case SyntaxKind.Decorator:
-                    return emitDecorator(<Decorator>node);
-
-                // Type members
-                case SyntaxKind.PropertySignature:
-                    return emitPropertySignature(<PropertySignature>node);
-                case SyntaxKind.PropertyDeclaration:
-                    return emitPropertyDeclaration(<PropertyDeclaration>node);
-                case SyntaxKind.MethodSignature:
-                    return emitMethodSignature(<MethodSignature>node);
-                case SyntaxKind.MethodDeclaration:
-                    return emitMethodDeclaration(<MethodDeclaration>node);
-                case SyntaxKind.Constructor:
-                    return emitConstructor(<ConstructorDeclaration>node);
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return emitAccessorDeclaration(<AccessorDeclaration>node);
-                case SyntaxKind.CallSignature:
-                    return emitCallSignature(<CallSignatureDeclaration>node);
-                case SyntaxKind.ConstructSignature:
-                    return emitConstructSignature(<ConstructSignatureDeclaration>node);
-                case SyntaxKind.IndexSignature:
-                    return emitIndexSignature(<IndexSignatureDeclaration>node);
-
-                // Types
-                case SyntaxKind.TypePredicate:
-                    return emitTypePredicate(<TypePredicateNode>node);
-                case SyntaxKind.TypeReference:
-                    return emitTypeReference(<TypeReferenceNode>node);
-                case SyntaxKind.FunctionType:
-                    return emitFunctionType(<FunctionTypeNode>node);
-                case SyntaxKind.ConstructorType:
-                    return emitConstructorType(<ConstructorTypeNode>node);
-                case SyntaxKind.TypeQuery:
-                    return emitTypeQuery(<TypeQueryNode>node);
-                case SyntaxKind.TypeLiteral:
-                    return emitTypeLiteral(<TypeLiteralNode>node);
-                case SyntaxKind.ArrayType:
-                    return emitArrayType(<ArrayTypeNode>node);
-                case SyntaxKind.TupleType:
-                    return emitTupleType(<TupleTypeNode>node);
-                case SyntaxKind.UnionType:
-                    return emitUnionType(<UnionTypeNode>node);
-                case SyntaxKind.IntersectionType:
-                    return emitIntersectionType(<IntersectionTypeNode>node);
-                case SyntaxKind.ParenthesizedType:
-                    return emitParenthesizedType(<ParenthesizedTypeNode>node);
-                case SyntaxKind.ExpressionWithTypeArguments:
-                    return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
-                case SyntaxKind.ThisType:
-                    return emitThisType();
-                case SyntaxKind.TypeOperator:
-                    return emitTypeOperator(<TypeOperatorNode>node);
-                case SyntaxKind.IndexedAccessType:
-                    return emitIndexedAccessType(<IndexedAccessTypeNode>node);
-                case SyntaxKind.MappedType:
-                    return emitMappedType(<MappedTypeNode>node);
-                case SyntaxKind.LiteralType:
-                    return emitLiteralType(<LiteralTypeNode>node);
-
-                // Binding patterns
-                case SyntaxKind.ObjectBindingPattern:
-                    return emitObjectBindingPattern(<ObjectBindingPattern>node);
-                case SyntaxKind.ArrayBindingPattern:
-                    return emitArrayBindingPattern(<ArrayBindingPattern>node);
-                case SyntaxKind.BindingElement:
-                    return emitBindingElement(<BindingElement>node);
-
-                // Misc
-                case SyntaxKind.TemplateSpan:
-                    return emitTemplateSpan(<TemplateSpan>node);
-                case SyntaxKind.SemicolonClassElement:
-                    return emitSemicolonClassElement();
-
-                // Statements
-                case SyntaxKind.Block:
-                    return emitBlock(<Block>node);
-                case SyntaxKind.VariableStatement:
-                    return emitVariableStatement(<VariableStatement>node);
-                case SyntaxKind.EmptyStatement:
-                    return emitEmptyStatement();
-                case SyntaxKind.ExpressionStatement:
-                    return emitExpressionStatement(<ExpressionStatement>node);
-                case SyntaxKind.IfStatement:
-                    return emitIfStatement(<IfStatement>node);
-                case SyntaxKind.DoStatement:
-                    return emitDoStatement(<DoStatement>node);
-                case SyntaxKind.WhileStatement:
-                    return emitWhileStatement(<WhileStatement>node);
-                case SyntaxKind.ForStatement:
-                    return emitForStatement(<ForStatement>node);
-                case SyntaxKind.ForInStatement:
-                    return emitForInStatement(<ForInStatement>node);
-                case SyntaxKind.ForOfStatement:
-                    return emitForOfStatement(<ForOfStatement>node);
-                case SyntaxKind.ContinueStatement:
-                    return emitContinueStatement(<ContinueStatement>node);
-                case SyntaxKind.BreakStatement:
-                    return emitBreakStatement(<BreakStatement>node);
-                case SyntaxKind.ReturnStatement:
-                    return emitReturnStatement(<ReturnStatement>node);
-                case SyntaxKind.WithStatement:
-                    return emitWithStatement(<WithStatement>node);
-                case SyntaxKind.SwitchStatement:
-                    return emitSwitchStatement(<SwitchStatement>node);
-                case SyntaxKind.LabeledStatement:
-                    return emitLabeledStatement(<LabeledStatement>node);
-                case SyntaxKind.ThrowStatement:
-                    return emitThrowStatement(<ThrowStatement>node);
-                case SyntaxKind.TryStatement:
-                    return emitTryStatement(<TryStatement>node);
-                case SyntaxKind.DebuggerStatement:
-                    return emitDebuggerStatement(<DebuggerStatement>node);
-
-                // Declarations
-                case SyntaxKind.VariableDeclaration:
-                    return emitVariableDeclaration(<VariableDeclaration>node);
-                case SyntaxKind.VariableDeclarationList:
-                    return emitVariableDeclarationList(<VariableDeclarationList>node);
-                case SyntaxKind.FunctionDeclaration:
-                    return emitFunctionDeclaration(<FunctionDeclaration>node);
-                case SyntaxKind.ClassDeclaration:
-                    return emitClassDeclaration(<ClassDeclaration>node);
-                case SyntaxKind.InterfaceDeclaration:
-                    return emitInterfaceDeclaration(<InterfaceDeclaration>node);
-                case SyntaxKind.TypeAliasDeclaration:
-                    return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);
-                case SyntaxKind.EnumDeclaration:
-                    return emitEnumDeclaration(<EnumDeclaration>node);
-                case SyntaxKind.ModuleDeclaration:
-                    return emitModuleDeclaration(<ModuleDeclaration>node);
-                case SyntaxKind.ModuleBlock:
-                    return emitModuleBlock(<ModuleBlock>node);
-                case SyntaxKind.CaseBlock:
-                    return emitCaseBlock(<CaseBlock>node);
-                case SyntaxKind.ImportEqualsDeclaration:
-                    return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
-                case SyntaxKind.ImportDeclaration:
-                    return emitImportDeclaration(<ImportDeclaration>node);
-                case SyntaxKind.ImportClause:
-                    return emitImportClause(<ImportClause>node);
-                case SyntaxKind.NamespaceImport:
-                    return emitNamespaceImport(<NamespaceImport>node);
-                case SyntaxKind.NamedImports:
-                    return emitNamedImports(<NamedImports>node);
-                case SyntaxKind.ImportSpecifier:
-                    return emitImportSpecifier(<ImportSpecifier>node);
-                case SyntaxKind.ExportAssignment:
-                    return emitExportAssignment(<ExportAssignment>node);
-                case SyntaxKind.ExportDeclaration:
-                    return emitExportDeclaration(<ExportDeclaration>node);
-                case SyntaxKind.NamedExports:
-                    return emitNamedExports(<NamedExports>node);
-                case SyntaxKind.ExportSpecifier:
-                    return emitExportSpecifier(<ExportSpecifier>node);
-                case SyntaxKind.MissingDeclaration:
-                    return;
-
-                // Module references
-                case SyntaxKind.ExternalModuleReference:
-                    return emitExternalModuleReference(<ExternalModuleReference>node);
-
-                // JSX (non-expression)
-                case SyntaxKind.JsxText:
-                    return emitJsxText(<JsxText>node);
-                case SyntaxKind.JsxOpeningElement:
-                    return emitJsxOpeningElement(<JsxOpeningElement>node);
-                case SyntaxKind.JsxClosingElement:
-                    return emitJsxClosingElement(<JsxClosingElement>node);
-                case SyntaxKind.JsxAttribute:
-                    return emitJsxAttribute(<JsxAttribute>node);
-                case SyntaxKind.JsxSpreadAttribute:
-                    return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);
-                case SyntaxKind.JsxExpression:
-                    return emitJsxExpression(<JsxExpression>node);
-
-                // Clauses
-                case SyntaxKind.CaseClause:
-                    return emitCaseClause(<CaseClause>node);
-                case SyntaxKind.DefaultClause:
-                    return emitDefaultClause(<DefaultClause>node);
-                case SyntaxKind.HeritageClause:
-                    return emitHeritageClause(<HeritageClause>node);
-                case SyntaxKind.CatchClause:
-                    return emitCatchClause(<CatchClause>node);
-
-                // Property assignments
-                case SyntaxKind.PropertyAssignment:
-                    return emitPropertyAssignment(<PropertyAssignment>node);
-                case SyntaxKind.ShorthandPropertyAssignment:
-                    return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);
-                case SyntaxKind.SpreadAssignment:
-                    return emitSpreadAssignment(node as SpreadAssignment);
-
-                // Enum
-                case SyntaxKind.EnumMember:
-                    return emitEnumMember(<EnumMember>node);
-
-                // JSDoc nodes (ignored)
-                // Transformation nodes (ignored)
-            }
-
-            // If the node is an expression, try to emit it as an expression with
-            // substitution.
-            if (isExpression(node)) {
-                return pipelineEmitWithSubstitution(EmitHint.Expression, node);
-            }
-        }
-
-        function pipelineEmitExpression(node: Node): void {
-            const kind = node.kind;
-            switch (kind) {
-                // Literals
-                case SyntaxKind.NumericLiteral:
-                    return emitNumericLiteral(<NumericLiteral>node);
-
-                case SyntaxKind.StringLiteral:
-                case SyntaxKind.RegularExpressionLiteral:
-                case SyntaxKind.NoSubstitutionTemplateLiteral:
-                    return emitLiteral(<LiteralExpression>node);
-
-                // Identifiers
-                case SyntaxKind.Identifier:
-                    return emitIdentifier(<Identifier>node);
-
-                // Reserved words
-                case SyntaxKind.FalseKeyword:
-                case SyntaxKind.NullKeyword:
-                case SyntaxKind.SuperKeyword:
-                case SyntaxKind.TrueKeyword:
-                case SyntaxKind.ThisKeyword:
-                    writeTokenText(kind);
-                    return;
-
-                // Expressions
-                case SyntaxKind.ArrayLiteralExpression:
-                    return emitArrayLiteralExpression(<ArrayLiteralExpression>node);
-                case SyntaxKind.ObjectLiteralExpression:
-                    return emitObjectLiteralExpression(<ObjectLiteralExpression>node);
-                case SyntaxKind.PropertyAccessExpression:
-                    return emitPropertyAccessExpression(<PropertyAccessExpression>node);
-                case SyntaxKind.ElementAccessExpression:
-                    return emitElementAccessExpression(<ElementAccessExpression>node);
-                case SyntaxKind.CallExpression:
-                    return emitCallExpression(<CallExpression>node);
-                case SyntaxKind.NewExpression:
-                    return emitNewExpression(<NewExpression>node);
-                case SyntaxKind.TaggedTemplateExpression:
-                    return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
-                case SyntaxKind.TypeAssertionExpression:
-                    return emitTypeAssertionExpression(<TypeAssertion>node);
-                case SyntaxKind.ParenthesizedExpression:
-                    return emitParenthesizedExpression(<ParenthesizedExpression>node);
-                case SyntaxKind.FunctionExpression:
-                    return emitFunctionExpression(<FunctionExpression>node);
-                case SyntaxKind.ArrowFunction:
-                    return emitArrowFunction(<ArrowFunction>node);
-                case SyntaxKind.DeleteExpression:
-                    return emitDeleteExpression(<DeleteExpression>node);
-                case SyntaxKind.TypeOfExpression:
-                    return emitTypeOfExpression(<TypeOfExpression>node);
-                case SyntaxKind.VoidExpression:
-                    return emitVoidExpression(<VoidExpression>node);
-                case SyntaxKind.AwaitExpression:
-                    return emitAwaitExpression(<AwaitExpression>node);
-                case SyntaxKind.PrefixUnaryExpression:
-                    return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);
-                case SyntaxKind.PostfixUnaryExpression:
-                    return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);
-                case SyntaxKind.BinaryExpression:
-                    return emitBinaryExpression(<BinaryExpression>node);
-                case SyntaxKind.ConditionalExpression:
-                    return emitConditionalExpression(<ConditionalExpression>node);
-                case SyntaxKind.TemplateExpression:
-                    return emitTemplateExpression(<TemplateExpression>node);
-                case SyntaxKind.YieldExpression:
-                    return emitYieldExpression(<YieldExpression>node);
-                case SyntaxKind.SpreadElement:
-                    return emitSpreadExpression(<SpreadElement>node);
-                case SyntaxKind.ClassExpression:
-                    return emitClassExpression(<ClassExpression>node);
-                case SyntaxKind.OmittedExpression:
-                    return;
-                case SyntaxKind.AsExpression:
-                    return emitAsExpression(<AsExpression>node);
-                case SyntaxKind.NonNullExpression:
-                    return emitNonNullExpression(<NonNullExpression>node);
-                case SyntaxKind.MetaProperty:
-                    return emitMetaProperty(<MetaProperty>node);
-
-                // JSX
-                case SyntaxKind.JsxElement:
-                    return emitJsxElement(<JsxElement>node);
-                case SyntaxKind.JsxSelfClosingElement:
-                    return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);
-
-                // Transformation nodes
-                case SyntaxKind.PartiallyEmittedExpression:
-                    return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
-            }
-        }
-
-        function emitBodyIndirect(node: Node, elements: NodeArray<Node>, emitCallback: (node: Node) => void): void {
-            if (onEmitDetachedCommentsOfNode) {
-                onEmitDetachedCommentsOfNode(node, elements, emitCallback);
-            }
-            else {
-                emitCallback(node);
-            }
-        }
-
-        function emitHelpersIndirect(node: Node) {
-            if (onEmitHelpers) {
-                onEmitHelpers(node, writeLines);
-            }
-        }
-
-        //
-        // Literals/Pseudo-literals
-        //
-
-        // SyntaxKind.NumericLiteral
-        function emitNumericLiteral(node: NumericLiteral) {
-            emitLiteral(node);
-            if (node.trailingComment) {
-                write(` /*${node.trailingComment}*/`);
-            }
-        }
-
-        // SyntaxKind.StringLiteral
-        // SyntaxKind.RegularExpressionLiteral
-        // SyntaxKind.NoSubstitutionTemplateLiteral
-        // SyntaxKind.TemplateHead
-        // SyntaxKind.TemplateMiddle
-        // SyntaxKind.TemplateTail
-        function emitLiteral(node: LiteralLikeNode) {
-            const text = getLiteralTextOfNode(node);
-            if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap)
-                && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
-                writer.writeLiteral(text);
-            }
-            else {
-                write(text);
-            }
-        }
-
-        //
-        // Identifiers
-        //
-
-        function emitIdentifier(node: Identifier) {
-            write(getTextOfNode(node, /*includeTrivia*/ false));
-        }
-
-        //
-        // Names
-        //
-
-        function emitQualifiedName(node: QualifiedName) {
-            emitEntityName(node.left);
-            write(".");
-            emit(node.right);
-        }
-
-        function emitEntityName(node: EntityName) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        function emitComputedPropertyName(node: ComputedPropertyName) {
-            write("[");
-            emitExpression(node.expression);
-            write("]");
-        }
-
-        //
-        // Signature elements
-        //
-
-        function emitTypeParameter(node: TypeParameterDeclaration) {
-            emit(node.name);
-            emitWithPrefix(" extends ", node.constraint);
-        }
-
-        function emitParameter(node: ParameterDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            writeIfPresent(node.dotDotDotToken, "...");
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitExpressionWithPrefix(" = ", node.initializer);
-            emitWithPrefix(": ", node.type);
-        }
-
-        function emitDecorator(decorator: Decorator) {
-            write("@");
-            emitExpression(decorator.expression);
-        }
-
-        //
-        // Type members
-        //
-
-        function emitPropertySignature(node: PropertySignature) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitPropertyDeclaration(node: PropertyDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            emitWithPrefix(": ", node.type);
-            emitExpressionWithPrefix(" = ", node.initializer);
-            write(";");
-        }
-
-        function emitMethodSignature(node: MethodSignature) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emit(node.name);
-            writeIfPresent(node.questionToken, "?");
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitMethodDeclaration(node: MethodDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            writeIfPresent(node.asteriskToken, "*");
-            emit(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitConstructor(node: ConstructorDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("constructor");
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitAccessorDeclaration(node: AccessorDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write(node.kind === SyntaxKind.GetAccessor ? "get " : "set ");
-            emit(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitCallSignature(node: CallSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitConstructSignature(node: ConstructSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("new ");
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitIndexSignature(node: IndexSignatureDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitParametersForIndexSignature(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(";");
-        }
-
-        function emitSemicolonClassElement() {
-            write(";");
-        }
-
-        //
-        // Types
-        //
-
-        function emitTypePredicate(node: TypePredicateNode) {
-            emit(node.parameterName);
-            write(" is ");
-            emit(node.type);
-        }
-
-        function emitTypeReference(node: TypeReferenceNode) {
-            emit(node.typeName);
-            emitTypeArguments(node, node.typeArguments);
-        }
-
-        function emitFunctionType(node: FunctionTypeNode) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            write(" => ");
-            emit(node.type);
-        }
-
-        function emitConstructorType(node: ConstructorTypeNode) {
-            write("new ");
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            write(" => ");
-            emit(node.type);
-        }
-
-        function emitTypeQuery(node: TypeQueryNode) {
-            write("typeof ");
-            emit(node.exprName);
-        }
-
-        function emitTypeLiteral(node: TypeLiteralNode) {
-            write("{");
-            emitList(node, node.members, ListFormat.TypeLiteralMembers);
-            write("}");
-        }
-
-        function emitArrayType(node: ArrayTypeNode) {
-            emit(node.elementType);
-            write("[]");
-        }
-
-        function emitTupleType(node: TupleTypeNode) {
-            write("[");
-            emitList(node, node.elementTypes, ListFormat.TupleTypeElements);
-            write("]");
-        }
-
-        function emitUnionType(node: UnionTypeNode) {
-            emitList(node, node.types, ListFormat.UnionTypeConstituents);
-        }
-
-        function emitIntersectionType(node: IntersectionTypeNode) {
-            emitList(node, node.types, ListFormat.IntersectionTypeConstituents);
-        }
-
-        function emitParenthesizedType(node: ParenthesizedTypeNode) {
-            write("(");
-            emit(node.type);
-            write(")");
-        }
-
-        function emitThisType() {
-            write("this");
-        }
-
-        function emitTypeOperator(node: TypeOperatorNode) {
-            writeTokenText(node.operator);
-            write(" ");
-            emit(node.type);
-        }
-
-        function emitIndexedAccessType(node: IndexedAccessTypeNode) {
-            emit(node.objectType);
-            write("[");
-            emit(node.indexType);
-            write("]");
-        }
-
-        function emitMappedType(node: MappedTypeNode) {
-            write("{");
-            writeLine();
-            increaseIndent();
-            writeIfPresent(node.readonlyToken, "readonly ");
-            write("[");
-            emit(node.typeParameter.name);
-            write(" in ");
-            emit(node.typeParameter.constraint);
-            write("]");
-            writeIfPresent(node.questionToken, "?");
-            write(": ");
-            emit(node.type);
-            write(";");
-            writeLine();
-            decreaseIndent();
-            write("}");
-        }
-
-        function emitLiteralType(node: LiteralTypeNode) {
-            emitExpression(node.literal);
-        }
-
-        //
-        // Binding patterns
-        //
-
-        function emitObjectBindingPattern(node: ObjectBindingPattern) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("{}");
-            }
-            else {
-                write("{");
-                emitList(node, elements, ListFormat.ObjectBindingPatternElements);
-                write("}");
-            }
-        }
-
-        function emitArrayBindingPattern(node: ArrayBindingPattern) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("[]");
-            }
-            else {
-                write("[");
-                emitList(node, node.elements, ListFormat.ArrayBindingPatternElements);
-                write("]");
-            }
-        }
-
-        function emitBindingElement(node: BindingElement) {
-            emitWithSuffix(node.propertyName, ": ");
-            writeIfPresent(node.dotDotDotToken, "...");
-            emit(node.name);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        //
-        // Expressions
-        //
-
-        function emitArrayLiteralExpression(node: ArrayLiteralExpression) {
-            const elements = node.elements;
-            if (elements.length === 0) {
-                write("[]");
-            }
-            else {
-                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
-                emitExpressionList(node, elements, ListFormat.ArrayLiteralExpressionElements | preferNewLine);
-            }
-        }
-
-        function emitObjectLiteralExpression(node: ObjectLiteralExpression) {
-            const properties = node.properties;
-            if (properties.length === 0) {
-                write("{}");
-            }
-            else {
-                const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-                if (indentedFlag) {
-                    increaseIndent();
-                }
-
-                const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;
-                const allowTrailingComma = languageVersion >= ScriptTarget.ES5 ? ListFormat.AllowTrailingComma : ListFormat.None;
-                emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine);
-
-                if (indentedFlag) {
-                    decreaseIndent();
-                }
-            }
-        }
-
-        function emitPropertyAccessExpression(node: PropertyAccessExpression) {
-            let indentBeforeDot = false;
-            let indentAfterDot = false;
-            if (!(getEmitFlags(node) & EmitFlags.NoIndentation)) {
-                const dotRangeStart = node.expression.end;
-                const dotRangeEnd = skipTrivia(currentSourceFile.text, node.expression.end) + 1;
-                const dotToken = <Node>{ kind: SyntaxKind.DotToken, pos: dotRangeStart, end: dotRangeEnd };
-                indentBeforeDot = needsIndentation(node, node.expression, dotToken);
-                indentAfterDot = needsIndentation(node, dotToken, node.name);
-            }
-
-            emitExpression(node.expression);
-            increaseIndentIf(indentBeforeDot);
-
-            const shouldEmitDotDot = !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
-            write(shouldEmitDotDot ? ".." : ".");
-
-            increaseIndentIf(indentAfterDot);
-            emit(node.name);
-            decreaseIndentIf(indentBeforeDot, indentAfterDot);
-        }
-
-        // 1..toString is a valid property access, emit a dot after the literal
-        // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal
-        function needsDotDotForPropertyAccess(expression: Expression) {
-            if (expression.kind === SyntaxKind.NumericLiteral) {
-                // check if numeric literal is a decimal literal that was originally written with a dot
-                const text = getLiteralTextOfNode(<LiteralExpression>expression);
-                return getNumericLiteralFlags(text, /*hint*/ NumericLiteralFlags.All) === NumericLiteralFlags.None
-                    && !(<LiteralExpression>expression).isOctalLiteral
-                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
-            }
-            else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
-                // check if constant enum value is integer
-                const constantValue = getConstantValue(expression);
-                // isFinite handles cases when constantValue is undefined
-                return isFinite(constantValue)
-                    && Math.floor(constantValue) === constantValue
-                    && compilerOptions.removeComments;
-            }
-        }
-
-        function emitElementAccessExpression(node: ElementAccessExpression) {
-            emitExpression(node.expression);
-            write("[");
-            emitExpression(node.argumentExpression);
-            write("]");
-        }
-
-        function emitCallExpression(node: CallExpression) {
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-            emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
-        }
-
-        function emitNewExpression(node: NewExpression) {
-            write("new ");
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-            emitExpressionList(node, node.arguments, ListFormat.NewExpressionArguments);
-        }
-
-        function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
-            emitExpression(node.tag);
-            write(" ");
-            emitExpression(node.template);
-        }
-
-        function emitTypeAssertionExpression(node: TypeAssertion) {
-            write("<");
-            emit(node.type);
-            write(">");
-            emitExpression(node.expression);
-        }
-
-        function emitParenthesizedExpression(node: ParenthesizedExpression) {
-            write("(");
-            emitExpression(node.expression);
-            write(")");
-        }
-
-        function emitFunctionExpression(node: FunctionExpression) {
-            emitFunctionDeclarationOrExpression(node);
-        }
-
-        function emitArrowFunction(node: ArrowFunction) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            emitSignatureAndBody(node, emitArrowFunctionHead);
-        }
-
-        function emitArrowFunctionHead(node: ArrowFunction) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-            write(" =>");
-        }
-
-        function emitDeleteExpression(node: DeleteExpression) {
-            write("delete ");
-            emitExpression(node.expression);
-        }
-
-        function emitTypeOfExpression(node: TypeOfExpression) {
-            write("typeof ");
-            emitExpression(node.expression);
-        }
-
-        function emitVoidExpression(node: VoidExpression) {
-            write("void ");
-            emitExpression(node.expression);
-        }
-
-        function emitAwaitExpression(node: AwaitExpression) {
-            write("await ");
-            emitExpression(node.expression);
-        }
-
-        function emitPrefixUnaryExpression(node: PrefixUnaryExpression) {
-            writeTokenText(node.operator);
-            if (shouldEmitWhitespaceBeforeOperand(node)) {
-                write(" ");
-            }
-            emitExpression(node.operand);
-        }
-
-        function shouldEmitWhitespaceBeforeOperand(node: PrefixUnaryExpression) {
-            // In some cases, we need to emit a space between the operator and the operand. One obvious case
-            // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
-            // and minus expressions in certain cases. Specifically, consider the following two cases (parens
-            // are just for clarity of exposition, and not part of the source code):
-            //
-            //  (+(+1))
-            //  (+(++1))
-            //
-            // We need to emit a space in both cases. In the first case, the absence of a space will make
-            // the resulting expression a prefix increment operation. And in the second, it will make the resulting
-            // expression a prefix increment whose operand is a plus expression - (++(+x))
-            // The same is true of minus of course.
-            const operand = node.operand;
-            return operand.kind === SyntaxKind.PrefixUnaryExpression
-                && ((node.operator === SyntaxKind.PlusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.PlusPlusToken))
-                || (node.operator === SyntaxKind.MinusToken && ((<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusToken || (<PrefixUnaryExpression>operand).operator === SyntaxKind.MinusMinusToken)));
-        }
-
-        function emitPostfixUnaryExpression(node: PostfixUnaryExpression) {
-            emitExpression(node.operand);
-            writeTokenText(node.operator);
-        }
-
-        function emitBinaryExpression(node: BinaryExpression) {
-            const isCommaOperator = node.operatorToken.kind !== SyntaxKind.CommaToken;
-            const indentBeforeOperator = needsIndentation(node, node.left, node.operatorToken);
-            const indentAfterOperator = needsIndentation(node, node.operatorToken, node.right);
-
-            emitExpression(node.left);
-            increaseIndentIf(indentBeforeOperator, isCommaOperator ? " " : undefined);
-            writeTokenText(node.operatorToken.kind);
-            increaseIndentIf(indentAfterOperator, " ");
-            emitExpression(node.right);
-            decreaseIndentIf(indentBeforeOperator, indentAfterOperator);
-        }
-
-        function emitConditionalExpression(node: ConditionalExpression) {
-            const indentBeforeQuestion = needsIndentation(node, node.condition, node.questionToken);
-            const indentAfterQuestion = needsIndentation(node, node.questionToken, node.whenTrue);
-            const indentBeforeColon = needsIndentation(node, node.whenTrue, node.colonToken);
-            const indentAfterColon = needsIndentation(node, node.colonToken, node.whenFalse);
-
-            emitExpression(node.condition);
-            increaseIndentIf(indentBeforeQuestion, " ");
-            write("?");
-            increaseIndentIf(indentAfterQuestion, " ");
-            emitExpression(node.whenTrue);
-            decreaseIndentIf(indentBeforeQuestion, indentAfterQuestion);
-
-            increaseIndentIf(indentBeforeColon, " ");
-            write(":");
-            increaseIndentIf(indentAfterColon, " ");
-            emitExpression(node.whenFalse);
-            decreaseIndentIf(indentBeforeColon, indentAfterColon);
-        }
-
-        function emitTemplateExpression(node: TemplateExpression) {
-            emit(node.head);
-            emitList(node, node.templateSpans, ListFormat.TemplateExpressionSpans);
-        }
-
-        function emitYieldExpression(node: YieldExpression) {
-            write(node.asteriskToken ? "yield*" : "yield");
-            emitExpressionWithPrefix(" ", node.expression);
-        }
-
-        function emitSpreadExpression(node: SpreadElement) {
-            write("...");
-            emitExpression(node.expression);
-        }
-
-        function emitClassExpression(node: ClassExpression) {
-            emitClassDeclarationOrExpression(node);
-        }
-
-        function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
-            emitExpression(node.expression);
-            emitTypeArguments(node, node.typeArguments);
-        }
-
-        function emitAsExpression(node: AsExpression) {
-            emitExpression(node.expression);
-            if (node.type) {
-                write(" as ");
-                emit(node.type);
-            }
-        }
-
-        function emitNonNullExpression(node: NonNullExpression) {
-            emitExpression(node.expression);
-            write("!");
-        }
-
-        function emitMetaProperty(node: MetaProperty) {
-            writeToken(node.keywordToken, node.pos);
-            write(".");
-            emit(node.name);
-        }
-
-        //
-        // Misc
-        //
-
-        function emitTemplateSpan(node: TemplateSpan) {
-            emitExpression(node.expression);
-            emit(node.literal);
-        }
-
-        //
-        // Statements
-        //
-
-        function emitBlock(node: Block) {
-            if (isSingleLineEmptyBlock(node)) {
-                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
-                write(" ");
-                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
-            }
-            else {
-                writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
-                emitBlockStatements(node);
-                writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
-            }
-        }
-
-        function emitBlockStatements(node: BlockLike) {
-            if (getEmitFlags(node) & EmitFlags.SingleLine) {
-                emitList(node, node.statements, ListFormat.SingleLineBlockStatements);
-            }
-            else {
-                emitList(node, node.statements, ListFormat.MultiLineBlockStatements);
-            }
-        }
-
-        function emitVariableStatement(node: VariableStatement) {
-            emitModifiers(node, node.modifiers);
-            emit(node.declarationList);
-            write(";");
-        }
-
-        function emitEmptyStatement() {
-            write(";");
-        }
-
-        function emitExpressionStatement(node: ExpressionStatement) {
-            emitExpression(node.expression);
-            write(";");
-        }
-
-        function emitIfStatement(node: IfStatement) {
-            const openParenPos = writeToken(SyntaxKind.IfKeyword, node.pos, node);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos, node);
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end, node);
-            emitEmbeddedStatement(node, node.thenStatement);
-            if (node.elseStatement) {
-                writeLineOrSpace(node);
-                writeToken(SyntaxKind.ElseKeyword, node.thenStatement.end, node);
-                if (node.elseStatement.kind === SyntaxKind.IfStatement) {
-                    write(" ");
-                    emit(node.elseStatement);
-                }
-                else {
-                    emitEmbeddedStatement(node, node.elseStatement);
-                }
-            }
-        }
-
-        function emitDoStatement(node: DoStatement) {
-            write("do");
-            emitEmbeddedStatement(node, node.statement);
-            if (isBlock(node.statement)) {
-                write(" ");
-            }
-            else {
-                writeLineOrSpace(node);
-            }
-
-            write("while (");
-            emitExpression(node.expression);
-            write(");");
-        }
-
-        function emitWhileStatement(node: WhileStatement) {
-            write("while (");
-            emitExpression(node.expression);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForStatement(node: ForStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos, /*contextNode*/ node);
-            emitForBinding(node.initializer);
-            write(";");
-            emitExpressionWithPrefix(" ", node.condition);
-            write(";");
-            emitExpressionWithPrefix(" ", node.incrementor);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForInStatement(node: ForInStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitForBinding(node.initializer);
-            write(" in ");
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForOfStatement(node: ForOfStatement) {
-            const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitForBinding(node.initializer);
-            write(" of ");
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitForBinding(node: VariableDeclarationList | Expression) {
-            if (node !== undefined) {
-                if (node.kind === SyntaxKind.VariableDeclarationList) {
-                    emit(node);
-                }
-                else {
-                    emitExpression(<Expression>node);
-                }
-            }
-        }
-
-        function emitContinueStatement(node: ContinueStatement) {
-            writeToken(SyntaxKind.ContinueKeyword, node.pos);
-            emitWithPrefix(" ", node.label);
-            write(";");
-        }
-
-        function emitBreakStatement(node: BreakStatement) {
-            writeToken(SyntaxKind.BreakKeyword, node.pos);
-            emitWithPrefix(" ", node.label);
-            write(";");
-        }
-
-        function emitReturnStatement(node: ReturnStatement) {
-            writeToken(SyntaxKind.ReturnKeyword, node.pos, /*contextNode*/ node);
-            emitExpressionWithPrefix(" ", node.expression);
-            write(";");
-        }
-
-        function emitWithStatement(node: WithStatement) {
-            write("with (");
-            emitExpression(node.expression);
-            write(")");
-            emitEmbeddedStatement(node, node.statement);
-        }
-
-        function emitSwitchStatement(node: SwitchStatement) {
-            const openParenPos = writeToken(SyntaxKind.SwitchKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emitExpression(node.expression);
-            writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            write(" ");
-            emit(node.caseBlock);
-        }
-
-        function emitLabeledStatement(node: LabeledStatement) {
-            emit(node.label);
-            write(": ");
-            emit(node.statement);
-        }
-
-        function emitThrowStatement(node: ThrowStatement) {
-            write("throw");
-            emitExpressionWithPrefix(" ", node.expression);
-            write(";");
-        }
-
-        function emitTryStatement(node: TryStatement) {
-            write("try ");
-            emit(node.tryBlock);
-            if (node.catchClause) {
-                writeLineOrSpace(node);
-                emit(node.catchClause);
-            }
-            if (node.finallyBlock) {
-                writeLineOrSpace(node);
-                write("finally ");
-                emit(node.finallyBlock);
-            }
-        }
-
-        function emitDebuggerStatement(node: DebuggerStatement) {
-            writeToken(SyntaxKind.DebuggerKeyword, node.pos);
-            write(";");
-        }
-
-        //
-        // Declarations
-        //
-
-        function emitVariableDeclaration(node: VariableDeclaration) {
-            emit(node.name);
-            emitWithPrefix(": ", node.type);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        function emitVariableDeclarationList(node: VariableDeclarationList) {
-            write(isLet(node) ? "let " : isConst(node) ? "const " : "var ");
-            emitList(node, node.declarations, ListFormat.VariableDeclarationList);
-        }
-
-        function emitFunctionDeclaration(node: FunctionDeclaration) {
-            emitFunctionDeclarationOrExpression(node);
-        }
-
-        function emitFunctionDeclarationOrExpression(node: FunctionDeclaration | FunctionExpression) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write(node.asteriskToken ? "function* " : "function ");
-            emitIdentifierName(node.name);
-            emitSignatureAndBody(node, emitSignatureHead);
-        }
-
-        function emitSignatureAndBody(node: FunctionLikeDeclaration, emitSignatureHead: (node: SignatureDeclaration) => void) {
-            const body = node.body;
-            if (body) {
-                if (isBlock(body)) {
-                    const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-                    if (indentedFlag) {
-                        increaseIndent();
-                    }
-
-                    if (getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
-                        emitSignatureHead(node);
-                        emitBlockFunctionBody(body);
-                    }
-                    else {
-                        pushNameGenerationScope();
-                        emitSignatureHead(node);
-                        emitBlockFunctionBody(body);
-                        popNameGenerationScope();
-                    }
-
-                    if (indentedFlag) {
-                        decreaseIndent();
-                    }
-                }
-                else {
-                    emitSignatureHead(node);
-                    write(" ");
-                    emitExpression(body);
-                }
-            }
-            else {
-                emitSignatureHead(node);
-                write(";");
-            }
-
-        }
-
-        function emitSignatureHead(node: FunctionDeclaration | FunctionExpression | MethodDeclaration | AccessorDeclaration | ConstructorDeclaration) {
-            emitTypeParameters(node, node.typeParameters);
-            emitParameters(node, node.parameters);
-            emitWithPrefix(": ", node.type);
-        }
-
-        function shouldEmitBlockFunctionBodyOnSingleLine(body: Block) {
-            // We must emit a function body as a single-line body in the following case:
-            // * The body has NodeEmitFlags.SingleLine specified.
-
-            // We must emit a function body as a multi-line body in the following cases:
-            // * The body is explicitly marked as multi-line.
-            // * A non-synthesized body's start and end position are on different lines.
-            // * Any statement in the body starts on a new line.
-
-            if (getEmitFlags(body) & EmitFlags.SingleLine) {
-                return true;
-            }
-
-            if (body.multiLine) {
-                return false;
-            }
-
-            if (!nodeIsSynthesized(body) && !rangeIsOnSingleLine(body, currentSourceFile)) {
-                return false;
-            }
-
-            if (shouldWriteLeadingLineTerminator(body, body.statements, ListFormat.PreserveLines)
-                || shouldWriteClosingLineTerminator(body, body.statements, ListFormat.PreserveLines)) {
-                return false;
-            }
-
-            let previousStatement: Statement;
-            for (const statement of body.statements) {
-                if (shouldWriteSeparatingLineTerminator(previousStatement, statement, ListFormat.PreserveLines)) {
-                    return false;
-                }
-
-                previousStatement = statement;
-            }
-
-            return true;
-        }
-
-        function emitBlockFunctionBody(body: Block) {
-            write(" {");
-            increaseIndent();
-
-            const emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body)
-                ? emitBlockFunctionBodyOnSingleLine
-                : emitBlockFunctionBodyWorker;
-
-            emitBodyIndirect(body, body.statements, emitBlockFunctionBody);
-
-            decreaseIndent();
-            writeToken(SyntaxKind.CloseBraceToken, body.statements.end, body);
-        }
-
-        function emitBlockFunctionBodyOnSingleLine(body: Block) {
-            emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true);
-        }
-
-        function emitBlockFunctionBodyWorker(body: Block, emitBlockFunctionBodyOnSingleLine?: boolean) {
-            // Emit all the prologue directives (like "use strict").
-            const statementOffset = emitPrologueDirectives(body.statements, /*startWithNewLine*/ true);
-            const pos = writer.getTextPos();
-            emitHelpersIndirect(body);
-            if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) {
-                decreaseIndent();
-                emitList(body, body.statements, ListFormat.SingleLineFunctionBodyStatements);
-                increaseIndent();
-            }
-            else {
-                emitList(body, body.statements, ListFormat.MultiLineFunctionBodyStatements, statementOffset);
-            }
-        }
-
-        function emitClassDeclaration(node: ClassDeclaration) {
-            emitClassDeclarationOrExpression(node);
-        }
-
-        function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("class");
-            emitNodeWithPrefix(" ", node.name, emitIdentifierName);
-
-            const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
-            if (indentedFlag) {
-                increaseIndent();
-            }
-
-            emitTypeParameters(node, node.typeParameters);
-            emitList(node, node.heritageClauses, ListFormat.ClassHeritageClauses);
-
-            pushNameGenerationScope();
-            write(" {");
-            emitList(node, node.members, ListFormat.ClassMembers);
-            write("}");
-            popNameGenerationScope();
-
-            if (indentedFlag) {
-                decreaseIndent();
-            }
-        }
-
-        function emitInterfaceDeclaration(node: InterfaceDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("interface ");
-            emit(node.name);
-            emitTypeParameters(node, node.typeParameters);
-            emitList(node, node.heritageClauses, ListFormat.HeritageClauses);
-            write(" {");
-            emitList(node, node.members, ListFormat.InterfaceMembers);
-            write("}");
-        }
-
-        function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {
-            emitDecorators(node, node.decorators);
-            emitModifiers(node, node.modifiers);
-            write("type ");
-            emit(node.name);
-            emitTypeParameters(node, node.typeParameters);
-            write(" = ");
-            emit(node.type);
-            write(";");
-        }
-
-        function emitEnumDeclaration(node: EnumDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("enum ");
-            emit(node.name);
-            pushNameGenerationScope();
-            write(" {");
-            emitList(node, node.members, ListFormat.EnumMembers);
-            write("}");
-            popNameGenerationScope();
-        }
-
-        function emitModuleDeclaration(node: ModuleDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
-            emit(node.name);
-
-            let body = node.body;
-            while (body.kind === SyntaxKind.ModuleDeclaration) {
-                write(".");
-                emit((<ModuleDeclaration>body).name);
-                body = (<ModuleDeclaration>body).body;
-            }
-
-            write(" ");
-            emit(body);
-        }
-
-        function emitModuleBlock(node: ModuleBlock) {
-            if (isEmptyBlock(node)) {
-                write("{ }");
-            }
-            else {
-                pushNameGenerationScope();
-                write("{");
-                increaseIndent();
-                emitBlockStatements(node);
-                write("}");
-                popNameGenerationScope();
-            }
-        }
-
-        function emitCaseBlock(node: CaseBlock) {
-            writeToken(SyntaxKind.OpenBraceToken, node.pos);
-            emitList(node, node.clauses, ListFormat.CaseBlockClauses);
-            writeToken(SyntaxKind.CloseBraceToken, node.clauses.end);
-        }
-
-        function emitImportEqualsDeclaration(node: ImportEqualsDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("import ");
-            emit(node.name);
-            write(" = ");
-            emitModuleReference(node.moduleReference);
-            write(";");
-        }
-
-        function emitModuleReference(node: ModuleReference) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        function emitImportDeclaration(node: ImportDeclaration) {
-            emitModifiers(node, node.modifiers);
-            write("import ");
-            if (node.importClause) {
-                emit(node.importClause);
-                write(" from ");
-            }
-            emitExpression(node.moduleSpecifier);
-            write(";");
-        }
-
-        function emitImportClause(node: ImportClause) {
-            emit(node.name);
-            if (node.name && node.namedBindings) {
-                write(", ");
-            }
-            emit(node.namedBindings);
-        }
-
-        function emitNamespaceImport(node: NamespaceImport) {
-            write("* as ");
-            emit(node.name);
-        }
-
-        function emitNamedImports(node: NamedImports) {
-            emitNamedImportsOrExports(node);
-        }
-
-        function emitImportSpecifier(node: ImportSpecifier) {
-            emitImportOrExportSpecifier(node);
-        }
-
-        function emitExportAssignment(node: ExportAssignment) {
-            write(node.isExportEquals ? "export = " : "export default ");
-            emitExpression(node.expression);
-            write(";");
-        }
-
-        function emitExportDeclaration(node: ExportDeclaration) {
-            write("export ");
-            if (node.exportClause) {
-                emit(node.exportClause);
-            }
-            else {
-                write("*");
-            }
-            if (node.moduleSpecifier) {
-                write(" from ");
-                emitExpression(node.moduleSpecifier);
-            }
-            write(";");
-        }
-
-        function emitNamedExports(node: NamedExports) {
-            emitNamedImportsOrExports(node);
-        }
-
-        function emitExportSpecifier(node: ExportSpecifier) {
-            emitImportOrExportSpecifier(node);
-        }
-
-        function emitNamedImportsOrExports(node: NamedImportsOrExports) {
-            write("{");
-            emitList(node, node.elements, ListFormat.NamedImportsOrExportsElements);
-            write("}");
-        }
-
-        function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
-            if (node.propertyName) {
-                emit(node.propertyName);
-                write(" as ");
-            }
-
-            emit(node.name);
-        }
-
-        //
-        // Module references
-        //
-
-        function emitExternalModuleReference(node: ExternalModuleReference) {
-            write("require(");
-            emitExpression(node.expression);
-            write(")");
-        }
-
-        //
-        // JSX
-        //
-
-        function emitJsxElement(node: JsxElement) {
-            emit(node.openingElement);
-            emitList(node, node.children, ListFormat.JsxElementChildren);
-            emit(node.closingElement);
-        }
-
-        function emitJsxSelfClosingElement(node: JsxSelfClosingElement) {
-            write("<");
-            emitJsxTagName(node.tagName);
-            write(" ");
-            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
-            write("/>");
-        }
-
-        function emitJsxOpeningElement(node: JsxOpeningElement) {
-            write("<");
-            emitJsxTagName(node.tagName);
-            writeIfAny(node.attributes, " ");
-            emitList(node, node.attributes, ListFormat.JsxElementAttributes);
-            write(">");
-        }
-
-        function emitJsxText(node: JsxText) {
-            writer.writeLiteral(getTextOfNode(node, /*includeTrivia*/ true));
-        }
-
-        function emitJsxClosingElement(node: JsxClosingElement) {
-            write("</");
-            emitJsxTagName(node.tagName);
-            write(">");
-        }
-
-        function emitJsxAttribute(node: JsxAttribute) {
-            emit(node.name);
-            emitWithPrefix("=", node.initializer);
-        }
-
-        function emitJsxSpreadAttribute(node: JsxSpreadAttribute) {
-            write("{...");
-            emitExpression(node.expression);
-            write("}");
-        }
-
-        function emitJsxExpression(node: JsxExpression) {
-            if (node.expression) {
-                write("{");
-                if (node.dotDotDotToken) {
-                    write("...");
-                }
-                emitExpression(node.expression);
-                write("}");
-            }
-        }
-
-        function emitJsxTagName(node: JsxTagNameExpression) {
-            if (node.kind === SyntaxKind.Identifier) {
-                emitExpression(<Identifier>node);
-            }
-            else {
-                emit(node);
-            }
-        }
-
-        //
-        // Clauses
-        //
-
-        function emitCaseClause(node: CaseClause) {
-            write("case ");
-            emitExpression(node.expression);
-            write(":");
-
-            emitCaseOrDefaultClauseStatements(node, node.statements);
-        }
-
-        function emitDefaultClause(node: DefaultClause) {
-            write("default:");
-            emitCaseOrDefaultClauseStatements(node, node.statements);
-        }
-
-        function emitCaseOrDefaultClauseStatements(parentNode: Node, statements: NodeArray<Statement>) {
-            const emitAsSingleStatement =
-                statements.length === 1 &&
-                (
-                    // treat synthesized nodes as located on the same line for emit purposes
-                    nodeIsSynthesized(parentNode) ||
-                    nodeIsSynthesized(statements[0]) ||
-                    rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)
-                );
-
-            if (emitAsSingleStatement) {
-                write(" ");
-                emit(statements[0]);
-            }
-            else {
-                emitList(parentNode, statements, ListFormat.CaseOrDefaultClauseStatements);
-            }
-        }
-
-        function emitHeritageClause(node: HeritageClause) {
-            write(" ");
-            writeTokenText(node.token);
-            write(" ");
-            emitList(node, node.types, ListFormat.HeritageClauseTypes);
-        }
-
-        function emitCatchClause(node: CatchClause) {
-            writeLine();
-            const openParenPos = writeToken(SyntaxKind.CatchKeyword, node.pos);
-            write(" ");
-            writeToken(SyntaxKind.OpenParenToken, openParenPos);
-            emit(node.variableDeclaration);
-            writeToken(SyntaxKind.CloseParenToken, node.variableDeclaration ? node.variableDeclaration.end : openParenPos);
-            write(" ");
-            emit(node.block);
-        }
-
-        //
-        // Property assignments
-        //
-
-        function emitPropertyAssignment(node: PropertyAssignment) {
-            emit(node.name);
-            write(": ");
-            // This is to ensure that we emit comment in the following case:
-            //      For example:
-            //          obj = {
-            //              id: /*comment1*/ ()=>void
-            //          }
-            // "comment1" is not considered to be leading comment for node.initializer
-            // but rather a trailing comment on the previous node.
-            const initializer = node.initializer;
-            if (onEmitTrailingCommentsOfPosition && (getEmitFlags(initializer) & EmitFlags.NoLeadingComments) === 0) {
-                const commentRange = getCommentRange(initializer);
-                onEmitTrailingCommentsOfPosition(commentRange.pos);
-            }
-            emitExpression(initializer);
-        }
-
-        function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {
-            emit(node.name);
-            if (node.objectAssignmentInitializer) {
-                write(" = ");
-                emitExpression(node.objectAssignmentInitializer);
-            }
-        }
-
-        function emitSpreadAssignment(node: SpreadAssignment) {
-            if (node.expression) {
-                write("...");
-                emitExpression(node.expression);
-            }
-        }
-
-        //
-        // Enum
-        //
-
-        function emitEnumMember(node: EnumMember) {
-            emit(node.name);
-            emitExpressionWithPrefix(" = ", node.initializer);
-        }
-
-        //
-        // Top-level nodes
-        //
-
-        function emitSourceFile(node: SourceFile) {
-            writeLine();
-            emitShebang();
-            emitBodyIndirect(node, node.statements, emitSourceFileWorker);
-        }
-
-        function emitSourceFileWorker(node: SourceFile) {
-            const statements = node.statements;
-            const statementOffset = emitPrologueDirectives(statements);
-            pushNameGenerationScope();
-            emitHelpersIndirect(node);
-            emitList(node, statements, ListFormat.MultiLine, statementOffset);
-            popNameGenerationScope();
-        }
-
-        // Transformation nodes
-
-        function emitPartiallyEmittedExpression(node: PartiallyEmittedExpression) {
-            emitExpression(node.expression);
-        }
-
-        /**
-         * Emits any prologue directives at the start of a Statement list, returning the
-         * number of prologue directives written to the output.
-         */
-        function emitPrologueDirectives(statements: Node[], startWithNewLine?: boolean): number {
-            for (let i = 0; i < statements.length; i++) {
-                if (isPrologueDirective(statements[i])) {
-                    if (startWithNewLine || i > 0) {
-                        writeLine();
-                    }
-                    emit(statements[i]);
-                }
-                else {
-                    // return index of the first non prologue directive
-                    return i;
-                }
-            }
-
-            return statements.length;
-        }
-
-        //
-        // Helpers
-        //
-
-        function emitShebang() {
-            const shebang = getShebang(currentSourceFile.text);
-            if (shebang) {
-                write(shebang);
-                writeLine();
-            }
-        }
-
-        function emitModifiers(node: Node, modifiers: NodeArray<Modifier>) {
-            if (modifiers && modifiers.length) {
-                emitList(node, modifiers, ListFormat.Modifiers);
-                write(" ");
-            }
-        }
-
-        function emitWithPrefix(prefix: string, node: Node) {
-            emitNodeWithPrefix(prefix, node, emit);
-        }
-
-        function emitExpressionWithPrefix(prefix: string, node: Node) {
-            emitNodeWithPrefix(prefix, node, emitExpression);
-        }
-
-        function emitNodeWithPrefix(prefix: string, node: Node, emit: (node: Node) => void) {
-            if (node) {
-                write(prefix);
-                emit(node);
-            }
-        }
-
-        function emitWithSuffix(node: Node, suffix: string) {
-            if (node) {
-                emit(node);
-                write(suffix);
-            }
-        }
-
-        function emitEmbeddedStatement(parent: Node, node: Statement) {
-            if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
-                write(" ");
-                emit(node);
-            }
-            else {
-                writeLine();
-                increaseIndent();
-                emit(node);
-                decreaseIndent();
-            }
-        }
-
-        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator>) {
-            emitList(parentNode, decorators, ListFormat.Decorators);
-        }
-
-        function emitTypeArguments(parentNode: Node, typeArguments: NodeArray<TypeNode>) {
-            emitList(parentNode, typeArguments, ListFormat.TypeArguments);
-        }
-
-        function emitTypeParameters(parentNode: Node, typeParameters: NodeArray<TypeParameterDeclaration>) {
-            emitList(parentNode, typeParameters, ListFormat.TypeParameters);
-        }
-
-        function emitParameters(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            emitList(parentNode, parameters, ListFormat.Parameters);
-        }
-
-        function emitParametersForArrow(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            if (parameters &&
-                parameters.length === 1 &&
-                parameters[0].type === undefined &&
-                parameters[0].pos === parentNode.pos) {
-                emit(parameters[0]);
-            }
-            else {
-                emitParameters(parentNode, parameters);
-            }
-        }
-
-        function emitParametersForIndexSignature(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            emitList(parentNode, parameters, ListFormat.IndexSignatureParameters);
-        }
-
-        function emitList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
-            emitNodeList(emit, parentNode, children, format, start, count);
-        }
-
-        function emitExpressionList(parentNode: Node, children: NodeArray<Node>, format: ListFormat, start?: number, count?: number) {
-            emitNodeList(emitExpression, parentNode, children, format, start, count);
-        }
-
-        function emitNodeList(emit: (node: Node) => void, parentNode: Node, children: NodeArray<Node>, format: ListFormat, start = 0, count = children ? children.length - start : 0) {
-            const isUndefined = children === undefined;
-            if (isUndefined && format & ListFormat.OptionalIfUndefined) {
-                return;
-            }
-
-            const isEmpty = isUndefined || children.length === 0 || start >= children.length || count === 0;
-            if (isEmpty && format & ListFormat.OptionalIfEmpty) {
-                return;
-            }
-
-            if (format & ListFormat.BracketsMask) {
-                write(getOpeningBracket(format));
-            }
-
-            if (isEmpty) {
-                // Write a line terminator if the parent node was multi-line
-                if (format & ListFormat.MultiLine) {
-                    writeLine();
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-            }
-            else {
-                // Write the opening line terminator or leading whitespace.
-                const mayEmitInterveningComments = (format & ListFormat.NoInterveningComments) === 0;
-                let shouldEmitInterveningComments = mayEmitInterveningComments;
-                if (shouldWriteLeadingLineTerminator(parentNode, children, format)) {
-                    writeLine();
-                    shouldEmitInterveningComments = false;
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-
-                // Increase the indent, if requested.
-                if (format & ListFormat.Indented) {
-                    increaseIndent();
-                }
-
-                // Emit each child.
-                let previousSibling: Node;
-                let shouldDecreaseIndentAfterEmit: boolean;
-                const delimiter = getDelimiter(format);
-                for (let i = 0; i < count; i++) {
-                    const child = children[start + i];
-
-                    // Write the delimiter if this is not the first node.
-                    if (previousSibling) {
-                        write(delimiter);
-
-                        // Write either a line terminator or whitespace to separate the elements.
-                        if (shouldWriteSeparatingLineTerminator(previousSibling, child, format)) {
-                            // If a synthesized node in a single-line list starts on a new
-                            // line, we should increase the indent.
-                            if ((format & (ListFormat.LinesMask | ListFormat.Indented)) === ListFormat.SingleLine) {
-                                increaseIndent();
-                                shouldDecreaseIndentAfterEmit = true;
-                            }
-
-                            writeLine();
-                            shouldEmitInterveningComments = false;
-                        }
-                        else if (previousSibling && format & ListFormat.SpaceBetweenSiblings) {
-                            write(" ");
-                        }
-                    }
-
-                    // Emit this child.
-                    if (shouldEmitInterveningComments) {
-                        if (onEmitTrailingCommentsOfPosition) {
-                            const commentRange = getCommentRange(child);
-                            onEmitTrailingCommentsOfPosition(commentRange.pos);
-                        }
-                    }
-                    else {
-                        shouldEmitInterveningComments = mayEmitInterveningComments;
-                    }
-
-                    emit(child);
-
-                    if (shouldDecreaseIndentAfterEmit) {
-                        decreaseIndent();
-                        shouldDecreaseIndentAfterEmit = false;
-                    }
-
-                    previousSibling = child;
-                }
-
-                // Write a trailing comma, if requested.
-                const hasTrailingComma = (format & ListFormat.AllowTrailingComma) && children.hasTrailingComma;
-                if (format & ListFormat.CommaDelimited && hasTrailingComma) {
-                    write(",");
-                }
-
-                // Decrease the indent, if requested.
-                if (format & ListFormat.Indented) {
-                    decreaseIndent();
-                }
-
-                // Write the closing line terminator or closing whitespace.
-                if (shouldWriteClosingLineTerminator(parentNode, children, format)) {
-                    writeLine();
-                }
-                else if (format & ListFormat.SpaceBetweenBraces) {
-                    write(" ");
-                }
-            }
-
-            if (format & ListFormat.BracketsMask) {
-                write(getClosingBracket(format));
-            }
-        }
-
-        function writeIfAny(nodes: NodeArray<Node>, text: string) {
-            if (some(nodes)) {
-                write(text);
-            }
-        }
-
-        function writeIfPresent(node: Node, text: string) {
-            if (node) {
-                write(text);
-            }
-        }
-
-        function writeToken(token: SyntaxKind, pos: number, contextNode?: Node) {
-            return onEmitSourceMapOfToken
-                ? onEmitSourceMapOfToken(contextNode, token, pos, writeTokenText)
-                : writeTokenText(token, pos);
-        }
-
-        function writeTokenText(token: SyntaxKind, pos?: number) {
-            const tokenString = tokenToString(token);
-            write(tokenString);
-            return pos < 0 ? pos : pos + tokenString.length;
-        }
-
-        function writeLineOrSpace(node: Node) {
-            if (getEmitFlags(node) & EmitFlags.SingleLine) {
-                write(" ");
-            }
-            else {
-                writeLine();
-            }
-        }
-
-        function writeLines(text: string): void {
-            const lines = text.split(/\r\n?|\n/g);
-            const indentation = guessIndentation(lines);
-            for (let i = 0; i < lines.length; i++) {
-                const line = indentation ? lines[i].slice(indentation) : lines[i];
-                if (line.length) {
-                    writeLine();
-                    write(line);
-                    writeLine();
-                }
-            }
-        }
-
-        function guessIndentation(lines: string[]) {
-            let indentation: number;
-            for (const line of lines) {
-                for (let i = 0; i < line.length && (indentation === undefined || i < indentation); i++) {
-                    if (!isWhiteSpace(line.charCodeAt(i))) {
-                        if (indentation === undefined || i < indentation) {
-                            indentation = i;
-                            break;
-                        }
-                    }
-                }
-            }
-            return indentation;
-        }
-
-        function increaseIndentIf(value: boolean, valueToWriteWhenNotIndenting?: string) {
-            if (value) {
-                increaseIndent();
-                writeLine();
-            }
-            else if (valueToWriteWhenNotIndenting) {
-                write(valueToWriteWhenNotIndenting);
-            }
-        }
-
-        // Helper function to decrease the indent if we previously indented.  Allows multiple
-        // previous indent values to be considered at a time.  This also allows caller to just
-        // call this once, passing in all their appropriate indent values, instead of needing
-        // to call this helper function multiple times.
-        function decreaseIndentIf(value1: boolean, value2?: boolean) {
-            if (value1) {
-                decreaseIndent();
-            }
-            if (value2) {
-                decreaseIndent();
-            }
-        }
-
-        function shouldWriteLeadingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return true;
-            }
-
-            if (format & ListFormat.PreserveLines) {
-                if (format & ListFormat.PreferNewLine) {
-                    return true;
-                }
-
-                const firstChild = children[0];
-                if (firstChild === undefined) {
-                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
-                }
-                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(firstChild)) {
-                    return synthesizedNodeStartsOnNewLine(firstChild, format);
-                }
-                else {
-                    return !rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile);
-                }
-            }
-            else {
-                return false;
-            }
-        }
-
-        function shouldWriteSeparatingLineTerminator(previousNode: Node, nextNode: Node, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return true;
-            }
-            else if (format & ListFormat.PreserveLines) {
-                if (previousNode === undefined || nextNode === undefined) {
-                    return false;
-                }
-                else if (nodeIsSynthesized(previousNode) || nodeIsSynthesized(nextNode)) {
-                    return synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format);
-                }
-                else {
-                    return !rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile);
-                }
-            }
-            else {
-                return nextNode.startsOnNewLine;
-            }
-        }
-
-        function shouldWriteClosingLineTerminator(parentNode: Node, children: NodeArray<Node>, format: ListFormat) {
-            if (format & ListFormat.MultiLine) {
-                return (format & ListFormat.NoTrailingNewLine) === 0;
-            }
-            else if (format & ListFormat.PreserveLines) {
-                if (format & ListFormat.PreferNewLine) {
-                    return true;
-                }
-
-                const lastChild = lastOrUndefined(children);
-                if (lastChild === undefined) {
-                    return !rangeIsOnSingleLine(parentNode, currentSourceFile);
-                }
-                else if (positionIsSynthesized(parentNode.pos) || nodeIsSynthesized(lastChild)) {
-                    return synthesizedNodeStartsOnNewLine(lastChild, format);
-                }
-                else {
-                    return !rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile);
-                }
-            }
-            else {
-                return false;
-            }
-        }
-
-        function synthesizedNodeStartsOnNewLine(node: Node, format?: ListFormat) {
-            if (nodeIsSynthesized(node)) {
-                const startsOnNewLine = node.startsOnNewLine;
-                if (startsOnNewLine === undefined) {
-                    return (format & ListFormat.PreferNewLine) !== 0;
-                }
-
-                return startsOnNewLine;
-            }
-
-            return (format & ListFormat.PreferNewLine) !== 0;
-        }
-
-        function needsIndentation(parent: Node, node1: Node, node2: Node): boolean {
-            parent = skipSynthesizedParentheses(parent);
-            node1 = skipSynthesizedParentheses(node1);
-            node2 = skipSynthesizedParentheses(node2);
-
-            // Always use a newline for synthesized code if the synthesizer desires it.
-            if (node2.startsOnNewLine) {
-                return true;
-            }
-
-            return !nodeIsSynthesized(parent)
-                && !nodeIsSynthesized(node1)
-                && !nodeIsSynthesized(node2)
-                && !rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile);
-        }
-
-        function isSingleLineEmptyBlock(block: Block) {
-            return !block.multiLine
-                && isEmptyBlock(block);
-        }
-
-        function isEmptyBlock(block: BlockLike) {
-            return block.statements.length === 0
-                && rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
-        }
-
-        function skipSynthesizedParentheses(node: Node) {
-            while (node.kind === SyntaxKind.ParenthesizedExpression && nodeIsSynthesized(node)) {
-                node = (<ParenthesizedExpression>node).expression;
-            }
-
-            return node;
-        }
-
-        function getTextOfNode(node: Node, includeTrivia?: boolean): string {
-            if (isGeneratedIdentifier(node)) {
-                return generateName(node);
-            }
-            else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
-                return unescapeIdentifier(node.text);
-            }
-            else if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
-                return getTextOfNode((<StringLiteral>node).textSourceNode, includeTrivia);
-            }
-            else if (isLiteralExpression(node) && (nodeIsSynthesized(node) || !node.parent)) {
-                return node.text;
-            }
-
-            return getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia);
-        }
-
-        function getLiteralTextOfNode(node: LiteralLikeNode): string {
-            if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
-                const textSourceNode = (<StringLiteral>node).textSourceNode;
-                if (isIdentifier(textSourceNode)) {
-                    return "\"" + escapeNonAsciiCharacters(escapeString(getTextOfNode(textSourceNode))) + "\"";
-                }
-                else {
-                    return getLiteralTextOfNode(textSourceNode);
-                }
-            }
-
-            return getLiteralText(node, currentSourceFile, languageVersion);
-        }
-
-        function resetGeneratedNames() {
-            nodeIdToGeneratedName = undefined;
-            autoGeneratedIdToGeneratedName = undefined;
-            generatedNames = undefined;
-            tempFlagsStack = undefined;
-            tempFlags = TempFlags.Auto;
-        }
-
-        function ensureNameGeneration() {
-            if (generatedNames === undefined) {
-                nodeIdToGeneratedName = [];
-                autoGeneratedIdToGeneratedName = [];
-                generatedNames = createMap<string>();
-                tempFlagsStack = [];
-            }
-        }
-
-        /**
-         * Push a new name generation scope.
-         */
-        function pushNameGenerationScope() {
-            ensureNameGeneration();
-            tempFlagsStack.push(tempFlags);
-            tempFlags = 0;
-        }
-
-        /**
-         * Pop the current name generation scope.
-         */
-        function popNameGenerationScope() {
-            ensureNameGeneration();
-            tempFlags = tempFlagsStack.pop();
-        }
-
-        /**
-         * Generate the text for a generated identifier.
-         */
-        function generateName(name: GeneratedIdentifier) {
-            ensureNameGeneration();
-            if (name.autoGenerateKind === GeneratedIdentifierKind.Node) {
-                // Node names generate unique names based on their original node
-                // and are cached based on that node's id.
-                const node = getNodeForGeneratedName(name);
-                return generateNameCached(node, getTextOfNode);
-            }
-            else {
-                // Auto, Loop, and Unique names are cached based on their unique
-                // autoGenerateId.
-                const autoGenerateId = name.autoGenerateId;
-                return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = unescapeIdentifier(makeName(name)));
-            }
-        }
-
-        function generateNameCached(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
-            const nodeId = getNodeId(node);
-            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node, getTextOfNode)));
-        }
-
-        /**
-         * Returns a value indicating whether a name is unique globally, within the current file,
-         * or within the NameGenerator.
-         */
-        function isUniqueName(name: string): boolean {
-            return !(hasGlobalName && hasGlobalName(name))
-                && !currentSourceFile.identifiers.has(name)
-                && !generatedNames.has(name);
-        }
-
-        /**
-         * Returns a value indicating whether a name is unique within a container.
-         */
-        function isUniqueLocalName(name: string, container: Node): boolean {
-            for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
-                if (node.locals) {
-                    const local = node.locals.get(name);
-                    // We conservatively include alias symbols to cover cases where they're emitted as locals
-                    if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-
-        /**
-         * Return the next available name in the pattern _a ... _z, _0, _1, ...
-         * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.
-         * Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
-         */
-        function makeTempVariableName(flags: TempFlags): string {
-            if (flags && !(tempFlags & flags)) {
-                const name = flags === TempFlags._i ? "_i" : "_n";
-                if (isUniqueName(name)) {
-                    tempFlags |= flags;
-                    return name;
-                }
-            }
-            while (true) {
-                const count = tempFlags & TempFlags.CountMask;
-                tempFlags++;
-                // Skip over 'i' and 'n'
-                if (count !== 8 && count !== 13) {
-                    const name = count < 26
-                        ? "_" + String.fromCharCode(CharacterCodes.a + count)
-                        : "_" + (count - 26);
-                    if (isUniqueName(name)) {
-                        return name;
-                    }
-                }
-            }
-        }
-
-        /**
-         * Generate a name that is unique within the current file and doesn't conflict with any names
-         * in global scope. The name is formed by adding an '_n' suffix to the specified base name,
-         * where n is a positive integer. Note that names generated by makeTempVariableName and
-         * makeUniqueName are guaranteed to never conflict.
-         */
-        function makeUniqueName(baseName: string): string {
-            // Find the first unique 'name_n', where n is a positive number
-            if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {
-                baseName += "_";
-            }
-            let i = 1;
-            while (true) {
-                const generatedName = baseName + i;
-                if (isUniqueName(generatedName)) {
-                    generatedNames.set(generatedName, generatedName);
-                    return generatedName;
-                }
-                i++;
-            }
-        }
-
-        /**
-         * Generates a unique name for a ModuleDeclaration or EnumDeclaration.
-         */
-        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
-            const name = getTextOfNode(node.name);
-            // Use module/enum name itself if it is unique, otherwise make a unique variation
-            return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
-        }
-
-        /**
-         * Generates a unique name for an ImportDeclaration or ExportDeclaration.
-         */
-        function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {
-            const expr = getExternalModuleName(node);
-            const baseName = expr.kind === SyntaxKind.StringLiteral ?
-                escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";
-            return makeUniqueName(baseName);
-        }
-
-        /**
-         * Generates a unique name for a default export.
-         */
-        function generateNameForExportDefault() {
-            return makeUniqueName("default");
-        }
-
-        /**
-         * Generates a unique name for a class expression.
-         */
-        function generateNameForClassExpression() {
-            return makeUniqueName("class");
-        }
-
-        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
-            if (isIdentifier(node.name)) {
-                return generateNameCached(node.name, getTextOfNode);
-            }
-            return makeTempVariableName(TempFlags.Auto);
-        }
-
-        /**
-         * Generates a unique name from a node.
-         */
-        function generateNameForNode(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string): string {
-            switch (node.kind) {
-                case SyntaxKind.Identifier:
-                    return makeUniqueName(getTextOfNode(node));
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node, getTextOfNode);
-                case SyntaxKind.ImportDeclaration:
-                case SyntaxKind.ExportDeclaration:
-                    return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.ExportAssignment:
-                    return generateNameForExportDefault();
-                case SyntaxKind.ClassExpression:
-                    return generateNameForClassExpression();
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node, getTextOfNode);
-                default:
-                    return makeTempVariableName(TempFlags.Auto);
-            }
-        }
-
-        /**
-         * Generates a unique identifier for a node.
-         */
-        function makeName(name: GeneratedIdentifier) {
-            switch (name.autoGenerateKind) {
-                case GeneratedIdentifierKind.Auto:
-                    return makeTempVariableName(TempFlags.Auto);
-                case GeneratedIdentifierKind.Loop:
-                    return makeTempVariableName(TempFlags._i);
-                case GeneratedIdentifierKind.Unique:
-                    return makeUniqueName(name.text);
-            }
-
-            Debug.fail("Unsupported GeneratedIdentifierKind.");
-        }
-
-        /**
-         * Gets the node from which a name should be generated.
-         */
-        function getNodeForGeneratedName(name: GeneratedIdentifier) {
-            const autoGenerateId = name.autoGenerateId;
-            let node = name as Node;
-            let original = node.original;
-            while (original) {
-                node = original;
-
-                // if "node" is a different generated name (having a different
-                // "autoGenerateId"), use it and stop traversing.
-                if (isIdentifier(node)
-                    && node.autoGenerateKind === GeneratedIdentifierKind.Node
-                    && node.autoGenerateId !== autoGenerateId) {
-                    break;
-                }
-
-                original = node.original;
-            }
-
-            // otherwise, return the original node for the source;
-            return node;
-        }
-    }
-
-    function createDelimiterMap() {
-        const delimiters: string[] = [];
-        delimiters[ListFormat.None] = "";
-        delimiters[ListFormat.CommaDelimited] = ",";
-        delimiters[ListFormat.BarDelimited] = " |";
-        delimiters[ListFormat.AmpersandDelimited] = " &";
-        return delimiters;
-    }
-
-    function getDelimiter(format: ListFormat) {
-        return delimiters[format & ListFormat.DelimitersMask];
-    }
-
-    function createBracketsMap() {
-        const brackets: string[][] = [];
-        brackets[ListFormat.Braces] = ["{", "}"];
-        brackets[ListFormat.Parenthesis] = ["(", ")"];
-        brackets[ListFormat.AngleBrackets] = ["<", ">"];
-        brackets[ListFormat.SquareBrackets] = ["[", "]"];
-        return brackets;
-    }
-
-    function getOpeningBracket(format: ListFormat) {
-        return brackets[format & ListFormat.BracketsMask][0];
-    }
-
-    function getClosingBracket(format: ListFormat) {
-        return brackets[format & ListFormat.BracketsMask][1];
-    }
-
-    const enum ListFormat {
-        None = 0,
-
-        // Line separators
-        SingleLine = 0,                 // Prints the list on a single line (default).
-        MultiLine = 1 << 0,             // Prints the list on multiple lines.
-        PreserveLines = 1 << 1,         // Prints the list using line preservation if possible.
-        LinesMask = SingleLine | MultiLine | PreserveLines,
-
-        // Delimiters
-        NotDelimited = 0,               // There is no delimiter between list items (default).
-        BarDelimited = 1 << 2,          // Each list item is space-and-bar (" |") delimited.
-        AmpersandDelimited = 1 << 3,    // Each list item is space-and-ampersand (" &") delimited.
-        CommaDelimited = 1 << 4,        // Each list item is comma (",") delimited.
-        DelimitersMask = BarDelimited | AmpersandDelimited | CommaDelimited,
-
-        AllowTrailingComma = 1 << 5,    // Write a trailing comma (",") if present.
-
-        // Whitespace
-        Indented = 1 << 6,              // The list should be indented.
-        SpaceBetweenBraces = 1 << 7,    // Inserts a space after the opening brace and before the closing brace.
-        SpaceBetweenSiblings = 1 << 8,  // Inserts a space between each sibling node.
-
-        // Brackets/Braces
-        Braces = 1 << 9,                 // The list is surrounded by "{" and "}".
-        Parenthesis = 1 << 10,          // The list is surrounded by "(" and ")".
-        AngleBrackets = 1 << 11,        // The list is surrounded by "<" and ">".
-        SquareBrackets = 1 << 12,       // The list is surrounded by "[" and "]".
-        BracketsMask = Braces | Parenthesis | AngleBrackets | SquareBrackets,
-
-        OptionalIfUndefined = 1 << 13,  // Do not emit brackets if the list is undefined.
-        OptionalIfEmpty = 1 << 14,      // Do not emit brackets if the list is empty.
-        Optional = OptionalIfUndefined | OptionalIfEmpty,
-
-        // Other
-        PreferNewLine = 1 << 15,        // Prefer adding a LineTerminator between synthesized nodes.
-        NoTrailingNewLine = 1 << 16,    // Do not emit a trailing NewLine for a MultiLine list.
-        NoInterveningComments = 1 << 17, // Do not emit comments between each node
-
-        // Precomputed Formats
-        Modifiers = SingleLine | SpaceBetweenSiblings,
-        HeritageClauses = SingleLine | SpaceBetweenSiblings,
-        TypeLiteralMembers = MultiLine | Indented,
-        TupleTypeElements = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented,
-        UnionTypeConstituents = BarDelimited | SpaceBetweenSiblings | SingleLine,
-        IntersectionTypeConstituents = AmpersandDelimited | SpaceBetweenSiblings | SingleLine,
-        ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings,
-        ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings,
-        ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces,
-        ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
-        CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,
-        NewExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis | OptionalIfUndefined,
-        TemplateExpressionSpans = SingleLine | NoInterveningComments,
-        SingleLineBlockStatements = SpaceBetweenBraces | SpaceBetweenSiblings | SingleLine,
-        MultiLineBlockStatements = Indented | MultiLine,
-        VariableDeclarationList = CommaDelimited | SpaceBetweenSiblings | SingleLine,
-        SingleLineFunctionBodyStatements = SingleLine | SpaceBetweenSiblings | SpaceBetweenBraces,
-        MultiLineFunctionBodyStatements = MultiLine,
-        ClassHeritageClauses = SingleLine | SpaceBetweenSiblings,
-        ClassMembers = Indented | MultiLine,
-        InterfaceMembers = Indented | MultiLine,
-        EnumMembers = CommaDelimited | Indented | MultiLine,
-        CaseBlockClauses = Indented | MultiLine,
-        NamedImportsOrExportsElements = CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | SingleLine | SpaceBetweenBraces,
-        JsxElementChildren = SingleLine | NoInterveningComments,
-        JsxElementAttributes = SingleLine | SpaceBetweenSiblings | NoInterveningComments,
-        CaseOrDefaultClauseStatements = Indented | MultiLine | NoTrailingNewLine | OptionalIfEmpty,
-        HeritageClauseTypes = CommaDelimited | SpaceBetweenSiblings | SingleLine,
-        SourceFileStatements = MultiLine | NoTrailingNewLine,
-        Decorators = MultiLine | Optional,
-        TypeArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
-        TypeParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | AngleBrackets | Optional,
-        Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis,
-        IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
-    }
-}
\ No newline at end of file
diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index 54d5eb77e10..52bb92ee1f0 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -34,7 +34,6 @@
         "comments.ts",
         "sourcemap.ts",
         "declarationEmitter.ts",
-        "printer.ts",
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 682cd9e617b..99cdca407b6 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -558,6 +558,15 @@
 
     export type ModifiersArray = NodeArray<Modifier>;
 
+    /*@internal*/
+    export const enum GeneratedIdentifierKind {
+        None,   // Not automatically generated.
+        Auto,   // Automatically generated identifier.
+        Loop,   // Automatically generated identifier with a preference for '_i'.
+        Unique, // Unique name based on the 'text' property.
+        Node,   // Unique name based on the node in the 'original' property.
+    }
+
     export interface Identifier extends PrimaryExpression {
         kind: SyntaxKind.Identifier;
         text: string;                                  // Text of identifier (with escapes converted to characters)
@@ -572,14 +581,7 @@
         resolvedSymbol: Symbol;
     }
 
-    export const enum GeneratedIdentifierKind {
-        None,   // Not automatically generated.
-        Auto,   // Automatically generated identifier.
-        Loop,   // Automatically generated identifier with a preference for '_i'.
-        Unique, // Unique name based on the 'text' property.
-        Node,   // Unique name based on the node in the 'original' property.
-    }
-
+    /*@internal*/
     export interface GeneratedIdentifier extends Identifier {
         autoGenerateKind: GeneratedIdentifierKind.Auto
                         | GeneratedIdentifierKind.Loop
@@ -3909,40 +3911,38 @@
     /* @internal */
     export type Transformer = (context: TransformationContext) => (node: SourceFile) => SourceFile;
 
-    export interface EmitTextWriter {
-        write(s: string): void;
-        writeTextOfNode(text: string, node: Node): void;
-        writeLine(): void;
-        increaseIndent(): void;
-        decreaseIndent(): void;
-        getText(): string;
-        rawWrite(s: string): void;
-        writeLiteral(s: string): void;
-        getTextPos(): number;
-        getLine(): number;
-        getColumn(): number;
-        getIndent(): number;
-        isAtStartOfLine(): boolean;
-        reset(): void;
+    export interface Printer {
+        printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string;
+        printFile(sourceFile: SourceFile): string;
+        printBundle(bundle: Bundle): string;
     }
 
+    /*@internal*/
     export interface Printer {
-        printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): void;
-        printFile(sourceFile: SourceFile): void;
-        printBundle(bundle: Bundle): void;
+        writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, writer: EmitTextWriter): void;
+        writeFile(sourceFile: SourceFile, writer: EmitTextWriter): void;
+        writeBundle(bundle: Bundle, writer: EmitTextWriter): void;
+    }
+
+    export interface PrintHandlers {
+        hasGlobalName?: (name: string) => boolean;
+        onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        onSubstituteNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        /*@internal*/ onEmitSourceMapOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        /*@internal*/ onEmitSourceMapOfToken?: (node: Node, token: SyntaxKind, pos: number, emitCallback: (token: SyntaxKind, pos: number) => number) => number;
+        /*@internal*/ onEmitSourceMapOfPosition?: (pos: number) => void;
+        /*@internal*/ onEmitHelpers?: (node: Node, writeLines: (text: string) => void) => void;
+        /*@internal*/ onSetSourceFile?: (node: SourceFile) => void;
     }
 
     export interface PrinterOptions {
-        hasGlobalName?: (name: string) => boolean;
-        onEmitSourceMapOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
-        onEmitSourceMapOfToken?: (node: Node, token: SyntaxKind, pos: number, emitCallback: (token: SyntaxKind, pos: number) => number) => number;
-        onEmitCommentsOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
-        onEmitDetachedCommentsOfNode?: (node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) => void;
-        onEmitTrailingCommentsOfPosition?: (pos: number) => void;
-        onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
-        onEmitHelpers?: (node: Node, writeLines: (text: string) => void) => void;
-        onSetSourceFile?: (node: SourceFile) => void;
-        onSubstituteNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        target?: ScriptTarget;
+        module?: ModuleKind;
+        removeComments?: boolean;
+        newLine?: NewLineKind;
+        /*@internal*/ sourceMap?: boolean;
+        /*@internal*/ inlineSourceMap?: boolean;
+        /*@internal*/ extendedDiagnostics?: boolean;
     }
 
     export interface TextSpan {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5c92bfa65cc..8d85ebeca99 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2439,6 +2439,23 @@ namespace ts {
             s;
     }
 
+    export interface EmitTextWriter {
+        write(s: string): void;
+        writeTextOfNode(text: string, node: Node): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        getText(): string;
+        rawWrite(s: string): void;
+        writeLiteral(s: string): void;
+        getTextPos(): number;
+        getLine(): number;
+        getColumn(): number;
+        getIndent(): number;
+        isAtStartOfLine(): boolean;
+        reset(): void;
+    }
+
     const indentStrings: string[] = ["", "    "];
     export function getIndentString(level: number) {
         if (indentStrings[level] === undefined) {
@@ -3215,7 +3232,7 @@ namespace ts {
 
     const carriageReturnLineFeed = "\r\n";
     const lineFeed = "\n";
-    export function getNewLineCharacter(options: CompilerOptions): string {
+    export function getNewLineCharacter(options: CompilerOptions | PrinterOptions): string {
         if (options.newLine === NewLineKind.CarriageReturnLineFeed) {
             return carriageReturnLineFeed;
         }
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index d7bb935db89..ebd07118cc5 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -37,7 +37,6 @@
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
-        "../compiler/printer.ts",
         "../compiler/emitter.ts",
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index 493f3b45f93..b60e00292f5 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -34,7 +34,6 @@
         "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
-        "../compiler/printer.ts",
         "../compiler/emitter.ts",
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",

From cca68adf877f5c91fcb8dd00842e985cecfdaa63 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 30 Jan 2017 12:42:19 -0800
Subject: [PATCH 134/159] Import helpers skips __assign when target >= ES6

Instead, Object.assign is emitted.
---
 src/compiler/checker.ts                          |  2 +-
 tests/baselines/reference/importHelpersES6.js    |  6 +++++-
 .../baselines/reference/importHelpersES6.symbols | 13 ++++++++-----
 tests/baselines/reference/importHelpersES6.types | 16 +++++++++++-----
 tests/cases/compiler/importHelpersES6.ts         |  4 +++-
 5 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 7d0f2cb0bbb..95dff83cd94 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -11721,7 +11721,7 @@ namespace ts {
                     member = prop;
                 }
                 else if (memberDecl.kind === SyntaxKind.SpreadAssignment) {
-                    if (languageVersion < ScriptTarget.ESNext) {
+                    if (languageVersion < ScriptTarget.ES2015) {
                         checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);
                     }
                     if (propertiesArray.length > 0) {
diff --git a/tests/baselines/reference/importHelpersES6.js b/tests/baselines/reference/importHelpersES6.js
index 209f3c34588..bc17939e2cc 100644
--- a/tests/baselines/reference/importHelpersES6.js
+++ b/tests/baselines/reference/importHelpersES6.js
@@ -5,10 +5,12 @@ declare var dec: any;
 @dec export class A {
 
 }
+
+const o = { a: 1 };
+const y = { ...o };
 
 //// [tslib.d.ts]
 export declare function __extends(d: Function, b: Function): void;
-export declare function __assign(t: any, ...sources: any[]): any;
 export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
 export declare function __param(paramIndex: number, decorator: Function): Function;
 export declare function __metadata(metadataKey: any, metadataValue: any): Function;
@@ -23,3 +25,5 @@ A = tslib_1.__decorate([
     dec
 ], A);
 export { A };
+const o = { a: 1 };
+const y = Object.assign({}, o);
diff --git a/tests/baselines/reference/importHelpersES6.symbols b/tests/baselines/reference/importHelpersES6.symbols
index 284a2251a6b..66a8b131aec 100644
--- a/tests/baselines/reference/importHelpersES6.symbols
+++ b/tests/baselines/reference/importHelpersES6.symbols
@@ -8,6 +8,14 @@ declare var dec: any;
 
 }
 
+const o = { a: 1 };
+>o : Symbol(o, Decl(a.ts, 5, 5))
+>a : Symbol(a, Decl(a.ts, 5, 11))
+
+const y = { ...o };
+>y : Symbol(y, Decl(a.ts, 6, 5))
+>o : Symbol(o, Decl(a.ts, 5, 5))
+
 === tests/cases/compiler/tslib.d.ts ===
 export declare function __extends(d: Function, b: Function): void;
 >__extends : Symbol(__extends, Decl(tslib.d.ts, --, --))
@@ -16,11 +24,6 @@ export declare function __extends(d: Function, b: Function): void;
 >b : Symbol(b, Decl(tslib.d.ts, --, --))
 >Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 
-export declare function __assign(t: any, ...sources: any[]): any;
->__assign : Symbol(__assign, Decl(tslib.d.ts, --, --))
->t : Symbol(t, Decl(tslib.d.ts, --, --))
->sources : Symbol(sources, Decl(tslib.d.ts, --, --))
-
 export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
 >__decorate : Symbol(__decorate, Decl(tslib.d.ts, --, --))
 >decorators : Symbol(decorators, Decl(tslib.d.ts, --, --))
diff --git a/tests/baselines/reference/importHelpersES6.types b/tests/baselines/reference/importHelpersES6.types
index ebfd5a5a2a5..26f30e32e58 100644
--- a/tests/baselines/reference/importHelpersES6.types
+++ b/tests/baselines/reference/importHelpersES6.types
@@ -8,6 +8,17 @@ declare var dec: any;
 
 }
 
+const o = { a: 1 };
+>o : { a: number; }
+>{ a: 1 } : { a: number; }
+>a : number
+>1 : 1
+
+const y = { ...o };
+>y : { a: number; }
+>{ ...o } : { a: number; }
+>o : { a: number; }
+
 === tests/cases/compiler/tslib.d.ts ===
 export declare function __extends(d: Function, b: Function): void;
 >__extends : (d: Function, b: Function) => void
@@ -16,11 +27,6 @@ export declare function __extends(d: Function, b: Function): void;
 >b : Function
 >Function : Function
 
-export declare function __assign(t: any, ...sources: any[]): any;
->__assign : (t: any, ...sources: any[]) => any
->t : any
->sources : any[]
-
 export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
 >__decorate : (decorators: Function[], target: any, key?: string | symbol, desc?: any) => any
 >decorators : Function[]
diff --git a/tests/cases/compiler/importHelpersES6.ts b/tests/cases/compiler/importHelpersES6.ts
index 9be680a88d6..0267156cf7e 100644
--- a/tests/cases/compiler/importHelpersES6.ts
+++ b/tests/cases/compiler/importHelpersES6.ts
@@ -7,9 +7,11 @@ declare var dec: any;
 
 }
 
+const o = { a: 1 };
+const y = { ...o };
+
 // @filename: tslib.d.ts
 export declare function __extends(d: Function, b: Function): void;
-export declare function __assign(t: any, ...sources: any[]): any;
 export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
 export declare function __param(paramIndex: number, decorator: Function): Function;
 export declare function __metadata(metadataKey: any, metadataValue: any): Function;

From 9b6f9305d99ed4424ac473f85955a9b10314d805 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Mon, 30 Jan 2017 13:19:44 -0800
Subject: [PATCH 135/159] support untyped imports in shims (#13758)

---
 src/services/shims.ts | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/services/shims.ts b/src/services/shims.ts
index cf6bceb816c..487947ee458 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -385,7 +385,10 @@ namespace ts {
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
             }
-            return <CompilerOptions>JSON.parse(settingsJson);
+            const compilerOptions = <CompilerOptions>JSON.parse(settingsJson);
+            // permit language service to handle all files (filtering should be performed on the host side)
+            compilerOptions.allowNonTsExtensions = true;
+            return compilerOptions;
         }
 
         public getScriptFileNames(): string[] {
@@ -1061,12 +1064,6 @@ namespace ts {
                 const compilerOptions = <CompilerOptions>JSON.parse(compilerOptionsJson);
                 const result = resolveModuleName(moduleName, normalizeSlashes(fileName), compilerOptions, this.host);
                 const resolvedFileName = result.resolvedModule ? result.resolvedModule.resolvedFileName : undefined;
-                if (resolvedFileName && !compilerOptions.allowJs && fileExtensionIs(resolvedFileName, ".js")) {
-                    return {
-                        resolvedFileName: undefined,
-                        failedLookupLocations: []
-                    };
-                }
                 return {
                     resolvedFileName,
                     failedLookupLocations: result.failedLookupLocations

From f0563ac2874190ef79549f17fdcf1da883add655 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Mon, 30 Jan 2017 13:40:42 -0800
Subject: [PATCH 136/159] Printer API unit tests

---
 Jakefile.js                                   |  1 +
 src/compiler/core.ts                          |  2 +-
 src/compiler/emitter.ts                       | 66 ++++---------
 src/compiler/types.ts                         |  1 -
 src/harness/tsconfig.json                     |  3 +-
 src/harness/unittests/printer.ts              | 97 +++++++++++++++++++
 .../printsBundleCorrectly.default.js          |  6 ++
 .../printsBundleCorrectly.removeComments.js   |  4 +
 .../printerApi/printsFileCorrectly.default.js | 25 +++++
 .../printsFileCorrectly.removeComments.js     | 17 ++++
 .../printerApi/printsNodeCorrectly.class.js   |  3 +
 11 files changed, 173 insertions(+), 52 deletions(-)
 create mode 100644 src/harness/unittests/printer.ts
 create mode 100644 tests/baselines/reference/printerApi/printsBundleCorrectly.default.js
 create mode 100644 tests/baselines/reference/printerApi/printsBundleCorrectly.removeComments.js
 create mode 100644 tests/baselines/reference/printerApi/printsFileCorrectly.default.js
 create mode 100644 tests/baselines/reference/printerApi/printsFileCorrectly.removeComments.js
 create mode 100644 tests/baselines/reference/printerApi/printsNodeCorrectly.class.js

diff --git a/Jakefile.js b/Jakefile.js
index 3ee8476c842..0b3a26dbb77 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -269,6 +269,7 @@ var harnessSources = harnessCoreSources.concat([
     "projectErrors.ts",
     "matchFiles.ts",
     "initializeTSConfig.ts",
+    "printer.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index b8097acaa71..304fba69b26 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1451,7 +1451,7 @@ namespace ts {
         return compilerOptions.target || ScriptTarget.ES3;
     }
 
-    export function getEmitModuleKind(compilerOptions: CompilerOptions | PrinterOptions) {
+    export function getEmitModuleKind(compilerOptions: CompilerOptions) {
         return typeof compilerOptions.module === "number" ?
             compilerOptions.module :
             getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? ModuleKind.ES2015 : ModuleKind.CommonJS;
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index b3bd594ae88..f20a7944a0f 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -12,6 +12,7 @@ namespace ts {
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
     export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean): EmitResult {
         const compilerOptions = host.getCompilerOptions();
+        const moduleKind = getEmitModuleKind(compilerOptions);
         const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
         const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
@@ -147,6 +148,10 @@ namespace ts {
         function emitHelpers(node: Node, writeLines: (text: string) => void) {
             let helpersEmitted = false;
             const bundle = node.kind === SyntaxKind.Bundle ? <Bundle>node : undefined;
+            if (bundle && moduleKind === ModuleKind.None) {
+                return;
+            }
+
             const numNodes = bundle ? bundle.sourceFiles.length : 1;
             for (let i = 0; i < numNodes; i++) {
                 const currentNode = bundle ? bundle.sourceFiles[i] : node;
@@ -201,7 +206,6 @@ namespace ts {
 
         const newLine = getNewLineCharacter(printerOptions);
         const languageVersion = getEmitScriptTarget(printerOptions);
-        const moduleKind = getEmitModuleKind(printerOptions);
         const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition);
         const {
             emitNodeWithComments,
@@ -257,9 +261,7 @@ namespace ts {
         function writeBundle(bundle: Bundle, output: EmitTextWriter) {
             const previousWriter = writer;
             setWriter(output);
-            if (moduleKind) {
-                emitHelpersIndirect(bundle);
-            }
+            emitHelpersIndirect(bundle);
             for (const sourceFile of bundle.sourceFiles) {
                 print(EmitHint.SourceFile, sourceFile, sourceFile);
             }
@@ -280,11 +282,8 @@ namespace ts {
         }
 
         function endPrint() {
-            const text = writer.getText();
-            if (writer === ownWriter) {
-                writer.reset();
-            }
-
+            const text = ownWriter.getText();
+            ownWriter.reset();
             return text;
         }
 
@@ -385,6 +384,15 @@ namespace ts {
 
         function pipelineEmitUnspecified(node: Node): void {
             const kind = node.kind;
+
+            // Reserved words
+            // Strict mode reserved words
+            // Contextual keywords
+            if (isKeyword(kind)) {
+                writeTokenText(kind);
+                return;
+            }
+
             switch (kind) {
                 // Pseudo-literals
                 case SyntaxKind.TemplateHead:
@@ -396,46 +404,6 @@ namespace ts {
                 case SyntaxKind.Identifier:
                     return emitIdentifier(<Identifier>node);
 
-                // Reserved words
-                case SyntaxKind.ConstKeyword:
-                case SyntaxKind.DefaultKeyword:
-                case SyntaxKind.ExportKeyword:
-                case SyntaxKind.VoidKeyword:
-
-                // Strict mode reserved words
-                case SyntaxKind.PrivateKeyword:
-                case SyntaxKind.ProtectedKeyword:
-                case SyntaxKind.PublicKeyword:
-                case SyntaxKind.StaticKeyword:
-
-                // Contextual keywords
-                case SyntaxKind.AbstractKeyword:
-                case SyntaxKind.AsKeyword:
-                case SyntaxKind.AnyKeyword:
-                case SyntaxKind.AsyncKeyword:
-                case SyntaxKind.AwaitKeyword:
-                case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.ConstructorKeyword:
-                case SyntaxKind.DeclareKeyword:
-                case SyntaxKind.GetKeyword:
-                case SyntaxKind.IsKeyword:
-                case SyntaxKind.ModuleKeyword:
-                case SyntaxKind.NamespaceKeyword:
-                case SyntaxKind.NeverKeyword:
-                case SyntaxKind.ReadonlyKeyword:
-                case SyntaxKind.RequireKeyword:
-                case SyntaxKind.NumberKeyword:
-                case SyntaxKind.SetKeyword:
-                case SyntaxKind.StringKeyword:
-                case SyntaxKind.SymbolKeyword:
-                case SyntaxKind.TypeKeyword:
-                case SyntaxKind.UndefinedKeyword:
-                case SyntaxKind.FromKeyword:
-                case SyntaxKind.GlobalKeyword:
-                case SyntaxKind.OfKeyword:
-                    writeTokenText(kind);
-                    return;
-
                 // Parse tree nodes
 
                 // Names
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 99cdca407b6..7e097ef40b1 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3937,7 +3937,6 @@
 
     export interface PrinterOptions {
         target?: ScriptTarget;
-        module?: ModuleKind;
         removeComments?: boolean;
         newLine?: NewLineKind;
         /*@internal*/ sourceMap?: boolean;
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index ebd07118cc5..bea688d358b 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -118,6 +118,7 @@
         "./unittests/initializeTSConfig.ts",
         "./unittests/compileOnSave.ts",
         "./unittests/typingsInstaller.ts",
-        "./unittests/projectErrors.ts"
+        "./unittests/projectErrors.ts",
+        "./unittests/printer.ts"
     ]
 }
diff --git a/src/harness/unittests/printer.ts b/src/harness/unittests/printer.ts
new file mode 100644
index 00000000000..2496a880bc5
--- /dev/null
+++ b/src/harness/unittests/printer.ts
@@ -0,0 +1,97 @@
+/// <reference path="..\..\compiler\emitter.ts" />
+/// <reference path="..\harness.ts" />
+
+namespace ts {
+    describe("PrinterAPI", () => {
+        function makePrintsCorrectly(prefix: string) {
+            return function printsCorrectly(name: string, options: PrinterOptions, printCallback: (printer: Printer) => string) {
+                it(name, () => {
+                    Harness.Baseline.runBaseline(`printerApi/${prefix}.${name}.js`, () =>
+                        printCallback(createPrinter({ newLine: NewLineKind.CarriageReturnLineFeed, ...options })));
+                });
+            }
+        }
+
+        describe("printFile", () => {
+            const printsCorrectly = makePrintsCorrectly("printsFileCorrectly");
+            const sourceFile = createSourceFile("source.ts", `
+                interface A<T> {
+                    // comment1
+                    readonly prop?: T;
+
+                    // comment2
+                    method(): void;
+
+                    // comment3
+                    new <T>(): A<T>;
+
+                    // comment4
+                    <T>(): A<T>;
+                }
+
+                // comment5
+                type B = number | string | object;
+                type C = A<number> & { x: string; }; // comment6
+
+                // comment7
+                enum E1 {
+                    // comment8
+                    first
+                }
+
+                const enum E2 {
+                    second
+                }
+
+                // comment9
+                console.log(1 + 2);
+            `, ScriptTarget.ES2015);
+
+            printsCorrectly("default", {}, printer => printer.printFile(sourceFile));
+            printsCorrectly("removeComments", { removeComments: true }, printer => printer.printFile(sourceFile));
+        });
+
+        describe("printBundle", () => {
+            const printsCorrectly = makePrintsCorrectly("printsBundleCorrectly");
+            const bundle = createBundle([
+                createSourceFile("a.ts", `
+                    /*! [a.ts] */
+
+                    // comment0
+                    const a = 1;
+                `, ScriptTarget.ES2015),
+                createSourceFile("b.ts", `
+                    /*! [b.ts] */
+
+                    // comment1
+                    const b = 2;
+                `, ScriptTarget.ES2015)
+            ]);
+            printsCorrectly("default", {}, printer => printer.printBundle(bundle));
+            printsCorrectly("removeComments", { removeComments: true }, printer => printer.printBundle(bundle));
+        });
+
+        describe("printNode", () => {
+            const printsCorrectly = makePrintsCorrectly("printsNodeCorrectly");
+            const sourceFile = createSourceFile("source.ts", "", ScriptTarget.ES2015);
+            const syntheticNode = createClassDeclaration(
+                undefined,
+                undefined,
+                /*name*/ createIdentifier("C"),
+                undefined,
+                undefined,
+                createNodeArray([
+                    createProperty(
+                        undefined,
+                        createNodeArray([createToken(SyntaxKind.PublicKeyword)]),
+                        createIdentifier("prop"),
+                        undefined,
+                        undefined,
+                        undefined
+                    )
+                ])
+            );
+            printsCorrectly("class", {}, printer => printer.printNode(EmitHint.Unspecified, syntheticNode, sourceFile));
+        });
+    });
+}
diff --git a/tests/baselines/reference/printerApi/printsBundleCorrectly.default.js b/tests/baselines/reference/printerApi/printsBundleCorrectly.default.js
new file mode 100644
index 00000000000..2d86cc0c09c
--- /dev/null
+++ b/tests/baselines/reference/printerApi/printsBundleCorrectly.default.js
@@ -0,0 +1,6 @@
+/*! [a.ts] */
+// comment0
+const a = 1;
+/*! [b.ts] */
+// comment1
+const b = 2;
diff --git a/tests/baselines/reference/printerApi/printsBundleCorrectly.removeComments.js b/tests/baselines/reference/printerApi/printsBundleCorrectly.removeComments.js
new file mode 100644
index 00000000000..22b03719cf3
--- /dev/null
+++ b/tests/baselines/reference/printerApi/printsBundleCorrectly.removeComments.js
@@ -0,0 +1,4 @@
+/*! [a.ts] */
+const a = 1;
+/*! [b.ts] */
+const b = 2;
diff --git a/tests/baselines/reference/printerApi/printsFileCorrectly.default.js b/tests/baselines/reference/printerApi/printsFileCorrectly.default.js
new file mode 100644
index 00000000000..9bff9d656b3
--- /dev/null
+++ b/tests/baselines/reference/printerApi/printsFileCorrectly.default.js
@@ -0,0 +1,25 @@
+interface A<T> {
+    // comment1
+    readonly prop?: T;
+    // comment2
+    method(): void;
+    // comment3
+    new <T>(): A<T>;
+    // comment4
+    <T>(): A<T>;
+}
+// comment5
+type B = number | string | object;
+type C = A<number> & {
+    x: string;
+}; // comment6
+// comment7
+enum E1 {
+    // comment8
+    first
+}
+const enum E2 {
+    second
+}
+// comment9
+console.log(1 + 2);
diff --git a/tests/baselines/reference/printerApi/printsFileCorrectly.removeComments.js b/tests/baselines/reference/printerApi/printsFileCorrectly.removeComments.js
new file mode 100644
index 00000000000..b511aff5e78
--- /dev/null
+++ b/tests/baselines/reference/printerApi/printsFileCorrectly.removeComments.js
@@ -0,0 +1,17 @@
+interface A<T> {
+    readonly prop?: T;
+    method(): void;
+    new <T>(): A<T>;
+    <T>(): A<T>;
+}
+type B = number | string | object;
+type C = A<number> & {
+    x: string;
+};
+enum E1 {
+    first
+}
+const enum E2 {
+    second
+}
+console.log(1 + 2);
diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.class.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.class.js
new file mode 100644
index 00000000000..fa19e836fed
--- /dev/null
+++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.class.js
@@ -0,0 +1,3 @@
+class C {
+    public prop;
+}
\ No newline at end of file

From 64ff691a2e9c2cf4f5eb651bffc2a19d82adccd3 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Mon, 30 Jan 2017 14:21:52 -0800
Subject: [PATCH 137/159] Move EmitTextWriter to types.ts

---
 src/compiler/types.ts     | 28 +++++++++++++++++++++-------
 src/compiler/utilities.ts | 17 -----------------
 2 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 7e097ef40b1..03098fd4129 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3915,13 +3915,9 @@
         printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string;
         printFile(sourceFile: SourceFile): string;
         printBundle(bundle: Bundle): string;
-    }
-
-    /*@internal*/
-    export interface Printer {
-        writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, writer: EmitTextWriter): void;
-        writeFile(sourceFile: SourceFile, writer: EmitTextWriter): void;
-        writeBundle(bundle: Bundle, writer: EmitTextWriter): void;
+        /*@internal*/ writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, writer: EmitTextWriter): void;
+        /*@internal*/ writeFile(sourceFile: SourceFile, writer: EmitTextWriter): void;
+        /*@internal*/ writeBundle(bundle: Bundle, writer: EmitTextWriter): void;
     }
 
     export interface PrintHandlers {
@@ -3944,6 +3940,24 @@
         /*@internal*/ extendedDiagnostics?: boolean;
     }
 
+    /*@internal*/
+    export interface EmitTextWriter {
+        write(s: string): void;
+        writeTextOfNode(text: string, node: Node): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        getText(): string;
+        rawWrite(s: string): void;
+        writeLiteral(s: string): void;
+        getTextPos(): number;
+        getLine(): number;
+        getColumn(): number;
+        getIndent(): number;
+        isAtStartOfLine(): boolean;
+        reset(): void;
+    }
+
     export interface TextSpan {
         start: number;
         length: number;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 8d85ebeca99..a2c5cbd15a3 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2439,23 +2439,6 @@ namespace ts {
             s;
     }
 
-    export interface EmitTextWriter {
-        write(s: string): void;
-        writeTextOfNode(text: string, node: Node): void;
-        writeLine(): void;
-        increaseIndent(): void;
-        decreaseIndent(): void;
-        getText(): string;
-        rawWrite(s: string): void;
-        writeLiteral(s: string): void;
-        getTextPos(): number;
-        getLine(): number;
-        getColumn(): number;
-        getIndent(): number;
-        isAtStartOfLine(): boolean;
-        reset(): void;
-    }
-
     const indentStrings: string[] = ["", "    "];
     export function getIndentString(level: number) {
         if (indentStrings[level] === undefined) {

From 16103a9ca2ba1d23e6e781fb16da83950eb073b8 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 15:40:31 -0800
Subject: [PATCH 138/159] Fix isSymbolInScopeOfMappedTypeParameter to include
 mapped types

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

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c2e0c66ce3f..780bda03b0a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6864,6 +6864,11 @@ namespace ts {
                             }
                         }
                         break;
+                    case SyntaxKind.MappedType:
+                        if (contains(mappedTypes, getDeclaredTypeOfTypeParameter(getSymbolOfNode((<MappedTypeNode>node).typeParameter)))) {
+                            return true;
+                        }
+                        break;
                     case SyntaxKind.JSDocFunctionType:
                         const func = node as JSDocFunctionType;
                         for (const p of func.parameters) {

From 34b4dbb26000d726600c4565ccb75cbc4eb53d06 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 15:47:18 -0800
Subject: [PATCH 139/159] Add regression test

---
 .../conformance/types/keyof/keyofAndIndexedAccess.ts   | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
index 04c26fbe8f7..a8a5acd450f 100644
--- a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
+++ b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
@@ -517,3 +517,13 @@ class B extends A<{ x: number}> {
 		p.x;
 	}
 }
+
+// Repro from #13749
+
+class Form<T> {
+    private childFormFactories: {[K in keyof T]: (v: T[K]) => Form<T[K]>}
+
+    public set<K extends keyof T>(prop: K, value: T[K]) {
+        this.childFormFactories[prop](value)
+    }
+}

From ebba3d6ba672458aa9f98ceef665e153c570505c Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 15:47:24 -0800
Subject: [PATCH 140/159] Accept new baselines

---
 .../reference/keyofAndIndexedAccess.js        | 23 +++++++++++
 .../reference/keyofAndIndexedAccess.symbols   | 36 ++++++++++++++++++
 .../reference/keyofAndIndexedAccess.types     | 38 +++++++++++++++++++
 3 files changed, 97 insertions(+)

diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js
index e7df8bbd5a1..62b848e97df 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.js
+++ b/tests/baselines/reference/keyofAndIndexedAccess.js
@@ -516,6 +516,16 @@ class B extends A<{ x: number}> {
 		p.x;
 	}
 }
+
+// Repro from #13749
+
+class Form<T> {
+    private childFormFactories: {[K in keyof T]: (v: T[K]) => Form<T[K]>}
+
+    public set<K extends keyof T>(prop: K, value: T[K]) {
+        this.childFormFactories[prop](value)
+    }
+}
 
 
 //// [keyofAndIndexedAccess.js]
@@ -862,6 +872,15 @@ var B = (function (_super) {
     };
     return B;
 }(A));
+// Repro from #13749
+var Form = (function () {
+    function Form() {
+    }
+    Form.prototype.set = function (prop, value) {
+        this.childFormFactories[prop](value);
+    };
+    return Form;
+}());
 
 
 //// [keyofAndIndexedAccess.d.ts]
@@ -1104,3 +1123,7 @@ declare class B extends A<{
 }> {
     f(p: this["props"]): void;
 }
+declare class Form<T> {
+    private childFormFactories;
+    set<K extends keyof T>(prop: K, value: T[K]): void;
+}
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index 01501cd719c..54fff19f428 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -1844,3 +1844,39 @@ class B extends A<{ x: number}> {
 	}
 }
 
+// Repro from #13749
+
+class Form<T> {
+>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+
+    private childFormFactories: {[K in keyof T]: (v: T[K]) => Form<T[K]>}
+>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+>v : Symbol(v, Decl(keyofAndIndexedAccess.ts, 521, 50))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34))
+>Form : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 521, 34))
+
+    public set<K extends keyof T>(prop: K, value: T[K]) {
+>set : Symbol(Form.set, Decl(keyofAndIndexedAccess.ts, 521, 73))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15))
+>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 520, 11))
+>K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 523, 15))
+
+        this.childFormFactories[prop](value)
+>this.childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15))
+>this : Symbol(Form, Decl(keyofAndIndexedAccess.ts, 516, 1))
+>childFormFactories : Symbol(Form.childFormFactories, Decl(keyofAndIndexedAccess.ts, 520, 15))
+>prop : Symbol(prop, Decl(keyofAndIndexedAccess.ts, 523, 34))
+>value : Symbol(value, Decl(keyofAndIndexedAccess.ts, 523, 42))
+    }
+}
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index 21c9d645ce4..e987ee9043b 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -2166,3 +2166,41 @@ class B extends A<{ x: number}> {
 	}
 }
 
+// Repro from #13749
+
+class Form<T> {
+>Form : Form<T>
+>T : T
+
+    private childFormFactories: {[K in keyof T]: (v: T[K]) => Form<T[K]>}
+>childFormFactories : { [K in keyof T]: (v: T[K]) => Form<T[K]>; }
+>K : K
+>T : T
+>v : T[K]
+>T : T
+>K : K
+>Form : Form<T>
+>T : T
+>K : K
+
+    public set<K extends keyof T>(prop: K, value: T[K]) {
+>set : <K extends keyof T>(prop: K, value: T[K]) => void
+>K : K
+>T : T
+>prop : K
+>K : K
+>value : T[K]
+>T : T
+>K : K
+
+        this.childFormFactories[prop](value)
+>this.childFormFactories[prop](value) : Form<T[K]>
+>this.childFormFactories[prop] : (v: T[K]) => Form<T[K]>
+>this.childFormFactories : { [K in keyof T]: (v: T[K]) => Form<T[K]>; }
+>this : this
+>childFormFactories : { [K in keyof T]: (v: T[K]) => Form<T[K]>; }
+>prop : K
+>value : T[K]
+    }
+}
+

From 7e7057a89d6780f0b093fef4be26c4ddeb4c62ef Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 16:53:31 -0800
Subject: [PATCH 141/159] Empty object type assignable to mapped type with
 optional properties

---
 src/compiler/checker.ts | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 780bda03b0a..26c27cb3be2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7687,7 +7687,7 @@ namespace ts {
             function isKnownProperty(type: Type, name: string): boolean {
                 if (type.flags & TypeFlags.Object) {
                     const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                    if ((relation === assignableRelation || relation === comparableRelation) && (type === globalObjectType || isEmptyObjectType(resolved)) ||
+                    if ((relation === assignableRelation || relation === comparableRelation) && (type === globalObjectType || isEmptyResolvedType(resolved)) ||
                         resolved.stringIndexInfo ||
                         (resolved.numberIndexInfo && isNumericLiteralName(name)) ||
                         getPropertyOfType(type, name)) {
@@ -7704,7 +7704,7 @@ namespace ts {
                 return false;
             }
 
-            function isEmptyObjectType(t: ResolvedType) {
+            function isEmptyResolvedType(t: ResolvedType) {
                 return t.properties.length === 0 &&
                     t.callSignatures.length === 0 &&
                     t.constructSignatures.length === 0 &&
@@ -7712,6 +7712,10 @@ namespace ts {
                     !t.numberIndexInfo;
             }
 
+            function isEmptyObjectType(type: Type) {
+                return type.flags & TypeFlags.Object && isEmptyResolvedType(resolveStructuredTypeMembers(<ObjectType>type));
+            }
+
             function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
                 if (maybeTypeOfKind(target, TypeFlags.Object) && !(getObjectFlags(target) & ObjectFlags.ObjectLiteralPatternWithComputedProperties)) {
                     for (const prop of getPropertiesOfObjectType(source)) {
@@ -7925,10 +7929,14 @@ namespace ts {
                             }
                         }
                     }
+                    else if ((<MappedType>target).declaration.questionToken && isEmptyObjectType(source)) {
+                        return Ternary.True;
+
+                    }
                 }
                 else if (relation !== identityRelation) {
                     const resolved = resolveStructuredTypeMembers(<ObjectType>target);
-                    if (isEmptyObjectType(resolved) || resolved.stringIndexInfo && resolved.stringIndexInfo.type.flags & TypeFlags.Any) {
+                    if (isEmptyResolvedType(resolved) || resolved.stringIndexInfo && resolved.stringIndexInfo.type.flags & TypeFlags.Any) {
                         return Ternary.True;
                     }
                 }

From 647e1836c3a8898d85b5c5a9371cd9bb98eec2b1 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 16:53:43 -0800
Subject: [PATCH 142/159] Add tests

---
 .../types/mapped/mappedTypesAndObjects.ts     | 24 +++++++++++++------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts b/tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts
index 8023f6e7d8d..b3530b46965 100644
--- a/tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts
+++ b/tests/cases/conformance/types/mapped/mappedTypesAndObjects.ts
@@ -13,23 +13,33 @@ function f2<T>(x: Partial<T>, y: Readonly<T>) {
     obj = y;
 }
 
+function f3<T>(x: Partial<T>) {
+    x = {};
+}
+
 // Repro from #12900
 
 interface Base {
-   foo: { [key: string]: any };
-   bar: any;
-   baz: any;
+    foo: { [key: string]: any };
+    bar: any;
+    baz: any;
 }
 
 interface E1<T> extends Base {
-  foo: T;
+    foo: T;
 }
 
 interface Something { name: string, value: string };
 interface E2 extends Base {
-  foo: Partial<Something>;  // or other mapped type
+    foo: Partial<Something>;  // or other mapped type
 }
 
 interface E3<T> extends Base {
-  foo: Partial<T>; // or other mapped type
-}
\ No newline at end of file
+    foo: Partial<T>; // or other mapped type
+}
+
+// Repro from #13747
+
+class Form<T> {
+    private values: {[P in keyof T]?: T[P]} = {}
+}

From 86591016186b41fc8b9db73fbbe8bdd3036c638d Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Mon, 30 Jan 2017 16:57:11 -0800
Subject: [PATCH 143/159] Accept new baselines

---
 .../reference/mappedTypesAndObjects.js        | 39 +++++++--
 .../reference/mappedTypesAndObjects.symbols   | 82 ++++++++++++-------
 .../reference/mappedTypesAndObjects.types     | 41 ++++++++--
 3 files changed, 121 insertions(+), 41 deletions(-)

diff --git a/tests/baselines/reference/mappedTypesAndObjects.js b/tests/baselines/reference/mappedTypesAndObjects.js
index 53b39209693..f320cc9624e 100644
--- a/tests/baselines/reference/mappedTypesAndObjects.js
+++ b/tests/baselines/reference/mappedTypesAndObjects.js
@@ -12,26 +12,37 @@ function f2<T>(x: Partial<T>, y: Readonly<T>) {
     obj = y;
 }
 
+function f3<T>(x: Partial<T>) {
+    x = {};
+}
+
 // Repro from #12900
 
 interface Base {
-   foo: { [key: string]: any };
-   bar: any;
-   baz: any;
+    foo: { [key: string]: any };
+    bar: any;
+    baz: any;
 }
 
 interface E1<T> extends Base {
-  foo: T;
+    foo: T;
 }
 
 interface Something { name: string, value: string };
 interface E2 extends Base {
-  foo: Partial<Something>;  // or other mapped type
+    foo: Partial<Something>;  // or other mapped type
 }
 
 interface E3<T> extends Base {
-  foo: Partial<T>; // or other mapped type
-}
+    foo: Partial<T>; // or other mapped type
+}
+
+// Repro from #13747
+
+class Form<T> {
+    private values: {[P in keyof T]?: T[P]} = {}
+}
+
 
 //// [mappedTypesAndObjects.js]
 function f1(x, y) {
@@ -44,12 +55,23 @@ function f2(x, y) {
     obj = x;
     obj = y;
 }
+function f3(x) {
+    x = {};
+}
 ;
+// Repro from #13747
+var Form = (function () {
+    function Form() {
+        this.values = {};
+    }
+    return Form;
+}());
 
 
 //// [mappedTypesAndObjects.d.ts]
 declare function f1<T>(x: Partial<T>, y: Readonly<T>): void;
 declare function f2<T>(x: Partial<T>, y: Readonly<T>): void;
+declare function f3<T>(x: Partial<T>): void;
 interface Base {
     foo: {
         [key: string]: any;
@@ -70,3 +92,6 @@ interface E2 extends Base {
 interface E3<T> extends Base {
     foo: Partial<T>;
 }
+declare class Form<T> {
+    private values;
+}
diff --git a/tests/baselines/reference/mappedTypesAndObjects.symbols b/tests/baselines/reference/mappedTypesAndObjects.symbols
index 1690f1b6b04..6fb5d720fb3 100644
--- a/tests/baselines/reference/mappedTypesAndObjects.symbols
+++ b/tests/baselines/reference/mappedTypesAndObjects.symbols
@@ -45,54 +45,80 @@ function f2<T>(x: Partial<T>, y: Readonly<T>) {
 >y : Symbol(y, Decl(mappedTypesAndObjects.ts, 7, 29))
 }
 
+function f3<T>(x: Partial<T>) {
+>f3 : Symbol(f3, Decl(mappedTypesAndObjects.ts, 11, 1))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12))
+>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15))
+>Partial : Symbol(Partial, Decl(lib.d.ts, --, --))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 13, 12))
+
+    x = {};
+>x : Symbol(x, Decl(mappedTypesAndObjects.ts, 13, 15))
+}
+
 // Repro from #12900
 
 interface Base {
->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 11, 1))
+>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1))
 
-   foo: { [key: string]: any };
->foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 15, 16))
->key : Symbol(key, Decl(mappedTypesAndObjects.ts, 16, 11))
+    foo: { [key: string]: any };
+>foo : Symbol(Base.foo, Decl(mappedTypesAndObjects.ts, 19, 16))
+>key : Symbol(key, Decl(mappedTypesAndObjects.ts, 20, 12))
 
-   bar: any;
->bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 16, 31))
+    bar: any;
+>bar : Symbol(Base.bar, Decl(mappedTypesAndObjects.ts, 20, 32))
 
-   baz: any;
->baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 17, 12))
+    baz: any;
+>baz : Symbol(Base.baz, Decl(mappedTypesAndObjects.ts, 21, 13))
 }
 
 interface E1<T> extends Base {
->E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 19, 1))
->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 21, 13))
->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 11, 1))
+>E1 : Symbol(E1, Decl(mappedTypesAndObjects.ts, 23, 1))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13))
+>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1))
 
-  foo: T;
->foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 21, 30))
->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 21, 13))
+    foo: T;
+>foo : Symbol(E1.foo, Decl(mappedTypesAndObjects.ts, 25, 30))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 25, 13))
 }
 
 interface Something { name: string, value: string };
->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 23, 1))
->name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 25, 21))
->value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 25, 35))
+>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1))
+>name : Symbol(Something.name, Decl(mappedTypesAndObjects.ts, 29, 21))
+>value : Symbol(Something.value, Decl(mappedTypesAndObjects.ts, 29, 35))
 
 interface E2 extends Base {
->E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 25, 52))
->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 11, 1))
+>E2 : Symbol(E2, Decl(mappedTypesAndObjects.ts, 29, 52))
+>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1))
 
-  foo: Partial<Something>;  // or other mapped type
->foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 26, 27))
+    foo: Partial<Something>;  // or other mapped type
+>foo : Symbol(E2.foo, Decl(mappedTypesAndObjects.ts, 30, 27))
 >Partial : Symbol(Partial, Decl(lib.d.ts, --, --))
->Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 23, 1))
+>Something : Symbol(Something, Decl(mappedTypesAndObjects.ts, 27, 1))
 }
 
 interface E3<T> extends Base {
->E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 28, 1))
->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 30, 13))
->Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 11, 1))
+>E3 : Symbol(E3, Decl(mappedTypesAndObjects.ts, 32, 1))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13))
+>Base : Symbol(Base, Decl(mappedTypesAndObjects.ts, 15, 1))
 
-  foo: Partial<T>; // or other mapped type
->foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 30, 30))
+    foo: Partial<T>; // or other mapped type
+>foo : Symbol(E3.foo, Decl(mappedTypesAndObjects.ts, 34, 30))
 >Partial : Symbol(Partial, Decl(lib.d.ts, --, --))
->T : Symbol(T, Decl(mappedTypesAndObjects.ts, 30, 13))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 34, 13))
 }
+
+// Repro from #13747
+
+class Form<T> {
+>Form : Symbol(Form, Decl(mappedTypesAndObjects.ts, 36, 1))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11))
+
+    private values: {[P in keyof T]?: T[P]} = {}
+>values : Symbol(Form.values, Decl(mappedTypesAndObjects.ts, 40, 15))
+>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11))
+>T : Symbol(T, Decl(mappedTypesAndObjects.ts, 40, 11))
+>P : Symbol(P, Decl(mappedTypesAndObjects.ts, 41, 22))
+}
+
diff --git a/tests/baselines/reference/mappedTypesAndObjects.types b/tests/baselines/reference/mappedTypesAndObjects.types
index e6f8e53f558..75f71082f31 100644
--- a/tests/baselines/reference/mappedTypesAndObjects.types
+++ b/tests/baselines/reference/mappedTypesAndObjects.types
@@ -49,19 +49,32 @@ function f2<T>(x: Partial<T>, y: Readonly<T>) {
 >y : Readonly<T>
 }
 
+function f3<T>(x: Partial<T>) {
+>f3 : <T>(x: Partial<T>) => void
+>T : T
+>x : Partial<T>
+>Partial : Partial<T>
+>T : T
+
+    x = {};
+>x = {} : {}
+>x : Partial<T>
+>{} : {}
+}
+
 // Repro from #12900
 
 interface Base {
 >Base : Base
 
-   foo: { [key: string]: any };
+    foo: { [key: string]: any };
 >foo : { [key: string]: any; }
 >key : string
 
-   bar: any;
+    bar: any;
 >bar : any
 
-   baz: any;
+    baz: any;
 >baz : any
 }
 
@@ -70,7 +83,7 @@ interface E1<T> extends Base {
 >T : T
 >Base : Base
 
-  foo: T;
+    foo: T;
 >foo : T
 >T : T
 }
@@ -84,7 +97,7 @@ interface E2 extends Base {
 >E2 : E2
 >Base : Base
 
-  foo: Partial<Something>;  // or other mapped type
+    foo: Partial<Something>;  // or other mapped type
 >foo : Partial<Something>
 >Partial : Partial<T>
 >Something : Something
@@ -95,8 +108,24 @@ interface E3<T> extends Base {
 >T : T
 >Base : Base
 
-  foo: Partial<T>; // or other mapped type
+    foo: Partial<T>; // or other mapped type
 >foo : Partial<T>
 >Partial : Partial<T>
 >T : T
 }
+
+// Repro from #13747
+
+class Form<T> {
+>Form : Form<T>
+>T : T
+
+    private values: {[P in keyof T]?: T[P]} = {}
+>values : { [P in keyof T]?: T[P] | undefined; }
+>P : P
+>T : T
+>T : T
+>P : P
+>{} : {}
+}
+

From 58cb9a7f08f73b19efb4db5e7bc07ac126a0759a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 30 Jan 2017 07:49:17 -0800
Subject: [PATCH 144/159] Use "ts2.2" (or "ts2.3", etc.) NPM tag in
 typingsInstaller

---
 src/harness/unittests/typingsInstaller.ts      | 18 ++++++++++--------
 .../typingsInstaller/typingsInstaller.ts       | 10 ++++++++--
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts
index d4956a387ee..2b79141c3e3 100644
--- a/src/harness/unittests/typingsInstaller.ts
+++ b/src/harness/unittests/typingsInstaller.ts
@@ -44,6 +44,8 @@ namespace ts.projectSystem {
         });
     }
 
+    import typingsName = server.typingsInstaller.typingsName;
+
     describe("typingsInstaller", () => {
         it("configured projects (typings installed) 1", () => {
             const file1 = {
@@ -519,32 +521,32 @@ namespace ts.projectSystem {
             const commander = {
                 path: "/a/data/node_modules/@types/commander/index.d.ts",
                 content: "declare const commander: { x: number }",
-                typings: "@types/commander"
+                typings: typingsName("commander")
             };
             const jquery = {
                 path: "/a/data/node_modules/@types/jquery/index.d.ts",
                 content: "declare const jquery: { x: number }",
-                typings: "@types/jquery"
+                typings: typingsName("jquery")
             };
             const lodash = {
                 path: "/a/data/node_modules/@types/lodash/index.d.ts",
                 content: "declare const lodash: { x: number }",
-                typings: "@types/lodash"
+                typings: typingsName("lodash")
             };
             const cordova = {
                 path: "/a/data/node_modules/@types/cordova/index.d.ts",
                 content: "declare const cordova: { x: number }",
-                typings: "@types/cordova"
+                typings: typingsName("cordova")
             };
             const grunt = {
                 path: "/a/data/node_modules/@types/grunt/index.d.ts",
                 content: "declare const grunt: { x: number }",
-                typings: "@types/grunt"
+                typings: typingsName("grunt")
             };
             const gulp = {
                 path: "/a/data/node_modules/@types/gulp/index.d.ts",
                 content: "declare const gulp: { x: number }",
-                typings: "@types/gulp"
+                typings: typingsName("gulp")
             };
 
             const host = createServerHost([lodashJs, commanderJs, file3]);
@@ -554,7 +556,7 @@ namespace ts.projectSystem {
                 }
                 installWorker(_requestId: number, args: string[], _cwd: string, cb: TI.RequestCompletedAction): void {
                     let typingFiles: (FileOrFolder & { typings: string })[] = [];
-                    if (args.indexOf("@types/commander") >= 0) {
+                    if (args.indexOf(typingsName("commander")) >= 0) {
                         typingFiles = [commander, jquery, lodash, cordova];
                     }
                     else {
@@ -982,7 +984,7 @@ namespace ts.projectSystem {
                         return;
                     }
                     if (response.kind === server.EventEndInstallTypes) {
-                        assert.deepEqual(response.packagesToInstall, ["@types/commander"]);
+                        assert.deepEqual(response.packagesToInstall, [typingsName("commander")]);
                         seenTelemetryEvent = true;
                         return;
                     }
diff --git a/src/server/typingsInstaller/typingsInstaller.ts b/src/server/typingsInstaller/typingsInstaller.ts
index 1869c542a6e..e889f98789a 100644
--- a/src/server/typingsInstaller/typingsInstaller.ts
+++ b/src/server/typingsInstaller/typingsInstaller.ts
@@ -295,8 +295,7 @@ namespace ts.server.typingsInstaller {
                 this.log.writeLine(`Installing typings ${JSON.stringify(typingsToInstall)}`);
             }
             const filteredTypings = this.filterTypings(typingsToInstall);
-            const scopedTypings = filteredTypings.map(x => `@types/${x}`);
-            if (scopedTypings.length === 0) {
+            if (filteredTypings.length === 0) {
                 if (this.log.isEnabled()) {
                     this.log.writeLine(`All typings are known to be missing or invalid - no need to go any further`);
                 }
@@ -316,6 +315,7 @@ namespace ts.server.typingsInstaller {
                 projectName: req.projectName
             });
 
+            const scopedTypings = filteredTypings.map(typingsName);
             this.installTypingsAsync(requestId, scopedTypings, cachePath, ok => {
                 try {
                     if (!ok) {
@@ -429,4 +429,10 @@ namespace ts.server.typingsInstaller {
         protected abstract installWorker(requestId: number, args: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void;
         protected abstract sendResponse(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes): void;
     }
+
+    /* @internal */
+    export function typingsName(packageName: string): string {
+        return `@types/${packageName}@ts${versionMajorMinor}`;
+    }
+    const versionMajorMinor = version.split(".").slice(0, 2).join(".");
 }
\ No newline at end of file

From 3b1b5e241f69bfcf49309094359e2620ada6cd06 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 31 Jan 2017 16:35:30 -0800
Subject: [PATCH 145/159] Add string literal completion for equality expression

---
 src/services/completions.ts                   | 24 +++++++++++++++++++
 .../fourslash/completionForStringLiteral10.ts | 12 ++++++++++
 .../fourslash/completionForStringLiteral8.ts  | 12 ++++++++++
 3 files changed, 48 insertions(+)
 create mode 100644 tests/cases/fourslash/completionForStringLiteral10.ts
 create mode 100644 tests/cases/fourslash/completionForStringLiteral8.ts

diff --git a/src/services/completions.ts b/src/services/completions.ts
index 5a08dbcb9c8..5d70b357625 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -173,6 +173,11 @@ namespace ts.Completions {
             //      var y = require("/*completion position*/");
             return getStringLiteralCompletionEntriesFromModuleNames(<StringLiteral>node, compilerOptions, host, typeChecker);
         }
+        else if (isEqualityExpression(node.parent)) {
+            // Get all known external module names or complete a path to a module
+            // i.e. x === '/*completion position'
+            return getStringLiteralCompletionEntriesFromBinaryExpression(<StringLiteral>node, node.parent, typeChecker);
+        }
         else {
             const argumentInfo = SignatureHelp.getImmediatelyContainingArgumentInfo(node, position, sourceFile);
             if (argumentInfo) {
@@ -240,6 +245,18 @@ namespace ts.Completions {
         return undefined;
     }
 
+    function getStringLiteralCompletionEntriesFromBinaryExpression(node: StringLiteral, parent: BinaryExpression, typeChecker: TypeChecker): CompletionInfo | undefined {
+        const type = typeChecker.getTypeAtLocation(parent.left === node ? parent.right : parent.left);
+        if (type) {
+            const entries: CompletionEntry[] = [];
+            addStringLiteralCompletionsFromType(type, entries, typeChecker);
+            if (entries.length) {
+                return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
+            }
+        }
+        return undefined;
+    }
+
     function addStringLiteralCompletionsFromType(type: Type, result: Push<CompletionEntry>, typeChecker: TypeChecker): void {
         if (type && type.flags & TypeFlags.TypeParameter) {
             type = typeChecker.getApparentType(type);
@@ -1756,4 +1773,11 @@ namespace ts.Completions {
         catch (e) {}
         return undefined;
     }
+
+    function isEqualityExpression(node: Node): node is BinaryExpression {
+        return isBinaryExpression(node) && (node.operatorToken.kind == SyntaxKind.EqualsEqualsToken ||
+            node.operatorToken.kind === SyntaxKind.ExclamationEqualsToken ||
+            node.operatorToken.kind === SyntaxKind.EqualsEqualsEqualsToken ||
+            node.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken);
+    }
 }
diff --git a/tests/cases/fourslash/completionForStringLiteral10.ts b/tests/cases/fourslash/completionForStringLiteral10.ts
new file mode 100644
index 00000000000..76a98eb732f
--- /dev/null
+++ b/tests/cases/fourslash/completionForStringLiteral10.ts
@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts'/>
+
+////type As = 'arf' | 'abacus' | 'abaddon';
+////let a: As;
+////if ('/**/' != a
+
+goTo.marker();
+verify.completionListContains("arf");
+verify.completionListContains("abacus");
+verify.completionListContains("abaddon");
+verify.completionListCount(3);
+
diff --git a/tests/cases/fourslash/completionForStringLiteral8.ts b/tests/cases/fourslash/completionForStringLiteral8.ts
new file mode 100644
index 00000000000..727bdf6e6a4
--- /dev/null
+++ b/tests/cases/fourslash/completionForStringLiteral8.ts
@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts'/>
+
+////type As = 'arf' | 'abacus' | 'abaddon';
+////let a: As;
+////if (a === '/**/
+
+goTo.marker();
+verify.completionListContains("arf");
+verify.completionListContains("abacus");
+verify.completionListContains("abaddon");
+verify.completionListCount(3);
+

From 52841924dad0909e1284352d1ab9b14c00437fda Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 31 Jan 2017 16:35:30 -0800
Subject: [PATCH 146/159] Support string literal completion in case labels

---
 src/services/completions.ts                   | 28 ++++++++-----------
 .../fourslash/completionForStringLiteral11.ts | 14 ++++++++++
 2 files changed, 25 insertions(+), 17 deletions(-)
 create mode 100644 tests/cases/fourslash/completionForStringLiteral11.ts

diff --git a/src/services/completions.ts b/src/services/completions.ts
index 5d70b357625..4c882c9b6b6 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -174,9 +174,16 @@ namespace ts.Completions {
             return getStringLiteralCompletionEntriesFromModuleNames(<StringLiteral>node, compilerOptions, host, typeChecker);
         }
         else if (isEqualityExpression(node.parent)) {
-            // Get all known external module names or complete a path to a module
+            // Get completions from the type of the other operand
+            // i.e. switch (a) {
+            //         case '/*completion position*/'
+            //      }
+            return getStringLiteralCompletionEntriesFromType(typeChecker.getTypeAtLocation(node.parent.left === node ? node.parent.right : node.parent.left), typeChecker);
+        }
+        else if (isCaseOrDefaultClause(node.parent)) {
+            // Get completions from the type of the switch expression
             // i.e. x === '/*completion position'
-            return getStringLiteralCompletionEntriesFromBinaryExpression(<StringLiteral>node, node.parent, typeChecker);
+            return getStringLiteralCompletionEntriesFromType(typeChecker.getTypeAtLocation((<SwitchStatement>node.parent.parent.parent).expression), typeChecker);
         }
         else {
             const argumentInfo = SignatureHelp.getImmediatelyContainingArgumentInfo(node, position, sourceFile);
@@ -189,7 +196,7 @@ namespace ts.Completions {
 
             // Get completion for string literal from string literal type
             // i.e. var x: "hi" | "hello" = "/*completion position*/"
-            return getStringLiteralCompletionEntriesFromContextualType(<StringLiteral>node, typeChecker);
+            return getStringLiteralCompletionEntriesFromType(typeChecker.getContextualType(<StringLiteral>node), typeChecker);
         }
     }
 
@@ -233,20 +240,7 @@ namespace ts.Completions {
         return undefined;
     }
 
-    function getStringLiteralCompletionEntriesFromContextualType(node: StringLiteral, typeChecker: TypeChecker): CompletionInfo | undefined {
-        const type = typeChecker.getContextualType(node);
-        if (type) {
-            const entries: CompletionEntry[] = [];
-            addStringLiteralCompletionsFromType(type, entries, typeChecker);
-            if (entries.length) {
-                return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
-            }
-        }
-        return undefined;
-    }
-
-    function getStringLiteralCompletionEntriesFromBinaryExpression(node: StringLiteral, parent: BinaryExpression, typeChecker: TypeChecker): CompletionInfo | undefined {
-        const type = typeChecker.getTypeAtLocation(parent.left === node ? parent.right : parent.left);
+    function getStringLiteralCompletionEntriesFromType(type: Type, typeChecker: TypeChecker): CompletionInfo | undefined {
         if (type) {
             const entries: CompletionEntry[] = [];
             addStringLiteralCompletionsFromType(type, entries, typeChecker);
diff --git a/tests/cases/fourslash/completionForStringLiteral11.ts b/tests/cases/fourslash/completionForStringLiteral11.ts
new file mode 100644
index 00000000000..f6acac28a65
--- /dev/null
+++ b/tests/cases/fourslash/completionForStringLiteral11.ts
@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts'/>
+
+////type As = 'arf' | 'abacus' | 'abaddon';
+////let a: As;
+////switch (a) {
+////    case '/**/
+////}
+
+goTo.marker();
+verify.completionListContains("arf");
+verify.completionListContains("abacus");
+verify.completionListContains("abaddon");
+verify.completionListCount(3);
+

From a39c14ec2e85bd61cd9c1820232e6840a5ffe07d Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Tue, 31 Jan 2017 21:34:25 -0800
Subject: [PATCH 147/159] Factor kind check to a separate function

---
 src/services/completions.ts | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/services/completions.ts b/src/services/completions.ts
index 4c882c9b6b6..df78ab931d1 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -1769,9 +1769,13 @@ namespace ts.Completions {
     }
 
     function isEqualityExpression(node: Node): node is BinaryExpression {
-        return isBinaryExpression(node) && (node.operatorToken.kind == SyntaxKind.EqualsEqualsToken ||
-            node.operatorToken.kind === SyntaxKind.ExclamationEqualsToken ||
-            node.operatorToken.kind === SyntaxKind.EqualsEqualsEqualsToken ||
-            node.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken);
+        return isBinaryExpression(node) && isEqualityOperatorKind(node.operatorToken.kind);
+    }
+
+    function isEqualityOperatorKind(kind: SyntaxKind) {
+        return kind == SyntaxKind.EqualsEqualsToken ||
+            kind === SyntaxKind.ExclamationEqualsToken ||
+            kind === SyntaxKind.EqualsEqualsEqualsToken ||
+            kind === SyntaxKind.ExclamationEqualsEqualsToken;
     }
 }

From 15c6022e40eae1549e3aa669f1819016cd90fcdb Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 09:32:33 -0800
Subject: [PATCH 148/159] Fix typo causing bug

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 26c27cb3be2..de7e9a9387f 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4929,7 +4929,7 @@ namespace ts {
         }
 
         function getApparentTypeOfIntersectionType(type: IntersectionType) {
-            return type.resolvedIndexType || (type.resolvedApparentType = getTypeWithThisArgument(type, type));
+            return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type));
         }
 
         /**

From 34ec8956421bdedbc53277e2d4c7fcb35ccf9e4d Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 09:47:30 -0800
Subject: [PATCH 149/159] Add regression test

---
 .../types/keyof/keyofAndIndexedAccess.ts      | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
index a8a5acd450f..70b70dff6ea 100644
--- a/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
+++ b/tests/cases/conformance/types/keyof/keyofAndIndexedAccess.ts
@@ -527,3 +527,30 @@ class Form<T> {
         this.childFormFactories[prop](value)
     }
 }
+
+// Repro from #13787
+
+class SampleClass<P> {
+    public props: Readonly<P>;
+    constructor(props: P) {
+        this.props = Object.freeze(props);
+    }
+}
+
+interface Foo {
+    foo: string;
+}
+
+declare function merge<T, U>(obj1: T, obj2: U): T & U;
+
+class AnotherSampleClass<T> extends SampleClass<T & Foo> {
+    constructor(props: T) {
+        const foo: Foo = { foo: "bar" };
+        super(merge(props, foo));
+    }
+
+    public brokenMethod() {
+        this.props.foo.concat;
+    }
+}
+new AnotherSampleClass({});

From 97828b4b9c79efa087c857b3492cf2373ae8699b Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 09:47:37 -0800
Subject: [PATCH 150/159] Accept new baselines

---
 .../reference/keyofAndIndexedAccess.js        | 60 ++++++++++++
 .../reference/keyofAndIndexedAccess.symbols   | 83 +++++++++++++++++
 .../reference/keyofAndIndexedAccess.types     | 91 +++++++++++++++++++
 3 files changed, 234 insertions(+)

diff --git a/tests/baselines/reference/keyofAndIndexedAccess.js b/tests/baselines/reference/keyofAndIndexedAccess.js
index 62b848e97df..2b1b22d3595 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.js
+++ b/tests/baselines/reference/keyofAndIndexedAccess.js
@@ -526,6 +526,33 @@ class Form<T> {
         this.childFormFactories[prop](value)
     }
 }
+
+// Repro from #13787
+
+class SampleClass<P> {
+    public props: Readonly<P>;
+    constructor(props: P) {
+        this.props = Object.freeze(props);
+    }
+}
+
+interface Foo {
+    foo: string;
+}
+
+declare function merge<T, U>(obj1: T, obj2: U): T & U;
+
+class AnotherSampleClass<T> extends SampleClass<T & Foo> {
+    constructor(props: T) {
+        const foo: Foo = { foo: "bar" };
+        super(merge(props, foo));
+    }
+
+    public brokenMethod() {
+        this.props.foo.concat;
+    }
+}
+new AnotherSampleClass({});
 
 
 //// [keyofAndIndexedAccess.js]
@@ -881,6 +908,27 @@ var Form = (function () {
     };
     return Form;
 }());
+// Repro from #13787
+var SampleClass = (function () {
+    function SampleClass(props) {
+        this.props = Object.freeze(props);
+    }
+    return SampleClass;
+}());
+var AnotherSampleClass = (function (_super) {
+    __extends(AnotherSampleClass, _super);
+    function AnotherSampleClass(props) {
+        var _this = this;
+        var foo = { foo: "bar" };
+        _this = _super.call(this, merge(props, foo)) || this;
+        return _this;
+    }
+    AnotherSampleClass.prototype.brokenMethod = function () {
+        this.props.foo.concat;
+    };
+    return AnotherSampleClass;
+}(SampleClass));
+new AnotherSampleClass({});
 
 
 //// [keyofAndIndexedAccess.d.ts]
@@ -1127,3 +1175,15 @@ declare class Form<T> {
     private childFormFactories;
     set<K extends keyof T>(prop: K, value: T[K]): void;
 }
+declare class SampleClass<P> {
+    props: Readonly<P>;
+    constructor(props: P);
+}
+interface Foo {
+    foo: string;
+}
+declare function merge<T, U>(obj1: T, obj2: U): T & U;
+declare class AnotherSampleClass<T> extends SampleClass<T & Foo> {
+    constructor(props: T);
+    brokenMethod(): void;
+}
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index 54fff19f428..f6425b5ed0e 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -1880,3 +1880,86 @@ class Form<T> {
     }
 }
 
+// Repro from #13787
+
+class SampleClass<P> {
+>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1))
+>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18))
+
+    public props: Readonly<P>;
+>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22))
+>Readonly : Symbol(Readonly, Decl(lib.d.ts, --, --))
+>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18))
+
+    constructor(props: P) {
+>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16))
+>P : Symbol(P, Decl(keyofAndIndexedAccess.ts, 530, 18))
+
+        this.props = Object.freeze(props);
+>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22))
+>this : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1))
+>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22))
+>Object.freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>freeze : Symbol(ObjectConstructor.freeze, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 532, 16))
+    }
+}
+
+interface Foo {
+>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1))
+
+    foo: string;
+>foo : Symbol(Foo.foo, Decl(keyofAndIndexedAccess.ts, 537, 15))
+}
+
+declare function merge<T, U>(obj1: T, obj2: U): T & U;
+>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23))
+>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25))
+>obj1 : Symbol(obj1, Decl(keyofAndIndexedAccess.ts, 541, 29))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23))
+>obj2 : Symbol(obj2, Decl(keyofAndIndexedAccess.ts, 541, 37))
+>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 541, 23))
+>U : Symbol(U, Decl(keyofAndIndexedAccess.ts, 541, 25))
+
+class AnotherSampleClass<T> extends SampleClass<T & Foo> {
+>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25))
+>SampleClass : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25))
+>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1))
+
+    constructor(props: T) {
+>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16))
+>T : Symbol(T, Decl(keyofAndIndexedAccess.ts, 543, 25))
+
+        const foo: Foo = { foo: "bar" };
+>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13))
+>Foo : Symbol(Foo, Decl(keyofAndIndexedAccess.ts, 535, 1))
+>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 26))
+
+        super(merge(props, foo));
+>super : Symbol(SampleClass, Decl(keyofAndIndexedAccess.ts, 526, 1))
+>merge : Symbol(merge, Decl(keyofAndIndexedAccess.ts, 539, 1))
+>props : Symbol(props, Decl(keyofAndIndexedAccess.ts, 544, 16))
+>foo : Symbol(foo, Decl(keyofAndIndexedAccess.ts, 545, 13))
+    }
+
+    public brokenMethod() {
+>brokenMethod : Symbol(AnotherSampleClass.brokenMethod, Decl(keyofAndIndexedAccess.ts, 547, 5))
+
+        this.props.foo.concat;
+>this.props.foo.concat : Symbol(String.concat, Decl(lib.d.ts, --, --))
+>this.props.foo : Symbol(foo)
+>this.props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22))
+>this : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54))
+>props : Symbol(SampleClass.props, Decl(keyofAndIndexedAccess.ts, 530, 22))
+>foo : Symbol(foo)
+>concat : Symbol(String.concat, Decl(lib.d.ts, --, --))
+    }
+}
+new AnotherSampleClass({});
+>AnotherSampleClass : Symbol(AnotherSampleClass, Decl(keyofAndIndexedAccess.ts, 541, 54))
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index e987ee9043b..86469efc284 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -2204,3 +2204,94 @@ class Form<T> {
     }
 }
 
+// Repro from #13787
+
+class SampleClass<P> {
+>SampleClass : SampleClass<P>
+>P : P
+
+    public props: Readonly<P>;
+>props : Readonly<P>
+>Readonly : Readonly<T>
+>P : P
+
+    constructor(props: P) {
+>props : P
+>P : P
+
+        this.props = Object.freeze(props);
+>this.props = Object.freeze(props) : Readonly<P>
+>this.props : Readonly<P>
+>this : this
+>props : Readonly<P>
+>Object.freeze(props) : Readonly<P>
+>Object.freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
+>Object : ObjectConstructor
+>freeze : { <T>(a: T[]): ReadonlyArray<T>; <T extends Function>(f: T): T; <T>(o: T): Readonly<T>; }
+>props : P
+    }
+}
+
+interface Foo {
+>Foo : Foo
+
+    foo: string;
+>foo : string
+}
+
+declare function merge<T, U>(obj1: T, obj2: U): T & U;
+>merge : <T, U>(obj1: T, obj2: U) => T & U
+>T : T
+>U : U
+>obj1 : T
+>T : T
+>obj2 : U
+>U : U
+>T : T
+>U : U
+
+class AnotherSampleClass<T> extends SampleClass<T & Foo> {
+>AnotherSampleClass : AnotherSampleClass<T>
+>T : T
+>SampleClass : SampleClass<T & Foo>
+>T : T
+>Foo : Foo
+
+    constructor(props: T) {
+>props : T
+>T : T
+
+        const foo: Foo = { foo: "bar" };
+>foo : Foo
+>Foo : Foo
+>{ foo: "bar" } : { foo: string; }
+>foo : string
+>"bar" : "bar"
+
+        super(merge(props, foo));
+>super(merge(props, foo)) : void
+>super : typeof SampleClass
+>merge(props, foo) : T & Foo
+>merge : <T, U>(obj1: T, obj2: U) => T & U
+>props : T
+>foo : Foo
+    }
+
+    public brokenMethod() {
+>brokenMethod : () => void
+
+        this.props.foo.concat;
+>this.props.foo.concat : (...strings: string[]) => string
+>this.props.foo : (T & Foo)["foo"]
+>this.props : Readonly<T & Foo>
+>this : this
+>props : Readonly<T & Foo>
+>foo : (T & Foo)["foo"]
+>concat : (...strings: string[]) => string
+    }
+}
+new AnotherSampleClass({});
+>new AnotherSampleClass({}) : AnotherSampleClass<{}>
+>AnotherSampleClass : typeof AnotherSampleClass
+>{} : {}
+

From 86b3c14099464ec43aabb961296f9098480766f6 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 11:36:33 -0800
Subject: [PATCH 151/159] Consider 'object' a valid base type + apparent type
 of 'object' is {}

---
 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 de7e9a9387f..b5306771dd7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3991,7 +3991,7 @@ namespace ts {
         // A valid base type is any non-generic object type or intersection of non-generic
         // object types.
         function isValidBaseType(type: Type): boolean {
-            return type.flags & TypeFlags.Object && !isGenericMappedType(type) ||
+            return type.flags & (TypeFlags.Object | TypeFlags.NonPrimitive) && !isGenericMappedType(type) ||
                 type.flags & TypeFlags.Intersection && !forEach((<IntersectionType>type).types, t => !isValidBaseType(t));
         }
 
@@ -4944,7 +4944,7 @@ namespace ts {
                 t.flags & TypeFlags.NumberLike ? globalNumberType :
                 t.flags & TypeFlags.BooleanLike ? globalBooleanType :
                 t.flags & TypeFlags.ESSymbol ? getGlobalESSymbolType() :
-                t.flags & TypeFlags.NonPrimitive ? globalObjectType :
+                t.flags & TypeFlags.NonPrimitive ? emptyObjectType :
                 t;
         }
 

From b6d612980c76f545d75cf669336457a33b85dec6 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 11:37:11 -0800
Subject: [PATCH 152/159] Accept baseline change for apparent type

---
 tests/baselines/reference/nonPrimitiveAssignError.errors.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/baselines/reference/nonPrimitiveAssignError.errors.txt b/tests/baselines/reference/nonPrimitiveAssignError.errors.txt
index a9bfaaa4a8a..f8c4450f3aa 100644
--- a/tests/baselines/reference/nonPrimitiveAssignError.errors.txt
+++ b/tests/baselines/reference/nonPrimitiveAssignError.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts(5,1): error TS2322: Type 'object' is not assignable to type '{ foo: string; }'.
-  Property 'foo' is missing in type 'Object'.
+  Property 'foo' is missing in type '{}'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts(13,1): error TS2322: Type 'number' is not assignable to type 'object'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts(14,1): error TS2322: Type 'true' is not assignable to type 'object'.
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts(15,1): error TS2322: Type 'string' is not assignable to type 'object'.
@@ -16,7 +16,7 @@ tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts(19,1): err
     y = a; // expect error
     ~
 !!! error TS2322: Type 'object' is not assignable to type '{ foo: string; }'.
-!!! error TS2322:   Property 'foo' is missing in type 'Object'.
+!!! error TS2322:   Property 'foo' is missing in type '{}'.
     a = x;
     a = y;
     

From a8de5ce836e54c4d8d3713a6db789b27402c399c Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 11:37:24 -0800
Subject: [PATCH 153/159] Add regression test

---
 tests/cases/conformance/classes/mixinClassesAnonymous.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/cases/conformance/classes/mixinClassesAnonymous.ts b/tests/cases/conformance/classes/mixinClassesAnonymous.ts
index 24289b61e3e..0e422888087 100644
--- a/tests/cases/conformance/classes/mixinClassesAnonymous.ts
+++ b/tests/cases/conformance/classes/mixinClassesAnonymous.ts
@@ -54,3 +54,11 @@ class Thing3 extends Thing2 {
         this.print();
     }
 }
+
+// Repro from #13805
+
+const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
+    return class extends Base {
+        timestamp = new Date();
+    };
+}

From 3a0a58d2e2274408788ff98246b001b176710617 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 1 Feb 2017 11:37:33 -0800
Subject: [PATCH 154/159] Accept new baselines

---
 .../reference/mixinClassesAnonymous.js        | 20 +++++++++++++++++
 .../reference/mixinClassesAnonymous.symbols   | 19 ++++++++++++++++
 .../reference/mixinClassesAnonymous.types     | 22 +++++++++++++++++++
 3 files changed, 61 insertions(+)

diff --git a/tests/baselines/reference/mixinClassesAnonymous.js b/tests/baselines/reference/mixinClassesAnonymous.js
index c7b8ab5fd63..aa148c25acf 100644
--- a/tests/baselines/reference/mixinClassesAnonymous.js
+++ b/tests/baselines/reference/mixinClassesAnonymous.js
@@ -55,6 +55,14 @@ class Thing3 extends Thing2 {
         this.print();
     }
 }
+
+// Repro from #13805
+
+const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
+    return class extends Base {
+        timestamp = new Date();
+    };
+}
 
 
 //// [mixinClassesAnonymous.js]
@@ -138,3 +146,15 @@ var Thing3 = (function (_super) {
     };
     return Thing3;
 }(Thing2));
+// Repro from #13805
+var Timestamped = function (Base) {
+    return (function (_super) {
+        __extends(class_2, _super);
+        function class_2() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.timestamp = new Date();
+            return _this;
+        }
+        return class_2;
+    }(Base));
+};
diff --git a/tests/baselines/reference/mixinClassesAnonymous.symbols b/tests/baselines/reference/mixinClassesAnonymous.symbols
index 204d9c589fd..bd709501f31 100644
--- a/tests/baselines/reference/mixinClassesAnonymous.symbols
+++ b/tests/baselines/reference/mixinClassesAnonymous.symbols
@@ -167,3 +167,22 @@ class Thing3 extends Thing2 {
     }
 }
 
+// Repro from #13805
+
+const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
+>Timestamped : Symbol(Timestamped, Decl(mixinClassesAnonymous.ts, 59, 5))
+>CT : Symbol(CT, Decl(mixinClassesAnonymous.ts, 59, 21))
+>Constructor : Symbol(Constructor, Decl(mixinClassesAnonymous.ts, 0, 0))
+>Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 59, 53))
+>CT : Symbol(CT, Decl(mixinClassesAnonymous.ts, 59, 21))
+
+    return class extends Base {
+>Base : Symbol(Base, Decl(mixinClassesAnonymous.ts, 59, 53))
+
+        timestamp = new Date();
+>timestamp : Symbol((Anonymous class).timestamp, Decl(mixinClassesAnonymous.ts, 60, 31))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    };
+}
+
diff --git a/tests/baselines/reference/mixinClassesAnonymous.types b/tests/baselines/reference/mixinClassesAnonymous.types
index 54b1c2c3819..516b15af2f3 100644
--- a/tests/baselines/reference/mixinClassesAnonymous.types
+++ b/tests/baselines/reference/mixinClassesAnonymous.types
@@ -198,3 +198,25 @@ class Thing3 extends Thing2 {
     }
 }
 
+// Repro from #13805
+
+const Timestamped = <CT extends Constructor<object>>(Base: CT) => {
+>Timestamped : <CT extends Constructor<object>>(Base: CT) => { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); } & CT
+><CT extends Constructor<object>>(Base: CT) => {    return class extends Base {        timestamp = new Date();    };} : <CT extends Constructor<object>>(Base: CT) => { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); } & CT
+>CT : CT
+>Constructor : Constructor<T>
+>Base : CT
+>CT : CT
+
+    return class extends Base {
+>class extends Base {        timestamp = new Date();    } : { new (...args: any[]): (Anonymous class); prototype: <any>.(Anonymous class); } & CT
+>Base : object
+
+        timestamp = new Date();
+>timestamp : Date
+>new Date() : Date
+>Date : DateConstructor
+
+    };
+}
+

From f02ce1f6a02661da69aade37d9d167274c23dad4 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Wed, 1 Feb 2017 15:22:35 -0800
Subject: [PATCH 155/159] PR Feedback

---
 src/compiler/comments.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts
index f69b4c546a0..200158c2f5c 100644
--- a/src/compiler/comments.ts
+++ b/src/compiler/comments.ts
@@ -11,7 +11,7 @@ namespace ts {
         emitTrailingCommentsOfPosition(pos: number): void;
     }
 
-    export function createCommentWriter(printerOptions: PrinterOptions, emitPos: (pos: number) => void): CommentWriter {
+    export function createCommentWriter(printerOptions: PrinterOptions, emitPos: ((pos: number) => void) | undefined): CommentWriter {
         const extendedDiagnostics = printerOptions.extendedDiagnostics;
         const newLine = getNewLineCharacter(printerOptions);
         let writer: EmitTextWriter;

From 984541316ac586bc9fdd385400b8858122a16baf Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Wed, 1 Feb 2017 16:16:04 -0800
Subject: [PATCH 156/159] Added comments and a few Debug assertions

---
 src/compiler/emitter.ts | 15 ++++++++++
 src/compiler/types.ts   | 66 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 78 insertions(+), 3 deletions(-)

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index f20a7944a0f..8c6868555f2 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -236,6 +236,21 @@ namespace ts {
         };
 
         function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string {
+            switch (hint) {
+                case EmitHint.SourceFile:
+                    Debug.assert(isSourceFile(node), "Expected a SourceFile node.");
+                    break;
+                case EmitHint.IdentifierName:
+                    Debug.assert(isIdentifier(node), "Expected an Identifier node.");
+                    break;
+                case EmitHint.Expression:
+                    Debug.assert(isExpression(node), "Expected an Expression node.");
+                    break;
+            }
+            switch (node.kind) {
+                case SyntaxKind.SourceFile: return printFile(<SourceFile>node);
+                case SyntaxKind.Bundle: return printBundle(<Bundle>node);
+            }
             writeNode(hint, node, sourceFile, beginPrint());
             return endPrint();
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 03098fd4129..8660e6138cd 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3912,8 +3912,27 @@
     export type Transformer = (context: TransformationContext) => (node: SourceFile) => SourceFile;
 
     export interface Printer {
+        /**
+         * Print a node and its subtree as-is, without any emit transformations.
+         * @param hint A value indicating the purpose of a node. This is primarily used to
+         * distinguish between an `Identifier` used in an expression position, versus an
+         * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you
+         * should just pass `Unspecified`.
+         * @param node The node to print. The node and its subtree are printed as-is, without any
+         * emit transformations.
+         * @param sourceFile A source file that provides context for the node. The source text of
+         * the file is used to emit the original source content for literals and identifiers, while
+         * the identifiers of the source file are used when generating unique names to avoid
+         * collisions.
+         */
         printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string;
+        /**
+         * Prints a source file as-is, without any emit transformations.
+         */
         printFile(sourceFile: SourceFile): string;
+        /**
+         * Prints a bundle of source files as-is, without any emit transformations.
+         */
         printBundle(bundle: Bundle): string;
         /*@internal*/ writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, writer: EmitTextWriter): void;
         /*@internal*/ writeFile(sourceFile: SourceFile, writer: EmitTextWriter): void;
@@ -3921,9 +3940,50 @@
     }
 
     export interface PrintHandlers {
-        hasGlobalName?: (name: string) => boolean;
-        onEmitNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
-        onSubstituteNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
+        /**
+         * A hook used by the Printer when generating unique names to avoid collisions with
+         * globally defined names that exist outside of the current source file.
+         */
+        hasGlobalName?(name: string): boolean;
+        /**
+         * A hook used by the Printer to provide notifications prior to emitting a node. A
+         * compatible implementation **must** invoke `emitCallback` with the provided `hint` and
+         * `node` values.
+         * @param hint A hint indicating the intended purpose of the node.
+         * @param node The node to emit.
+         * @param emitCallback A callback that, when invoked, will emit the node.
+         * @example
+         * ```ts
+         * var printer = createPrinter(printerOptions, {
+         *   onEmitNode(hint, node, emitCallback) {
+         *     // set up or track state prior to emitting the node...
+         *     emitCallback(hint, node);
+         *     // restore state after emitting the node...
+         *   }
+         * });
+         * ```
+         */
+        onEmitNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
+        /**
+         * A hook used by the Printer to perform just-in-time substitution of a node. This is
+         * primarily used by node transformations that need to substitute one node for another,
+         * such as replacing `myExportedVar` with `exports.myExportedVar`. A compatible
+         * implementation **must** invoke `emitCallback` eith the provided `hint` and either
+         * the provided `node`, or its substitute.
+         * @param hint A hint indicating the intended purpose of the node.
+         * @param node The node to emit.
+         * @param emitCallback A callback that, when invoked, will emit the node.
+         * @example
+         * ```ts
+         * var printer = createPrinter(printerOptions, {
+         *   onSubstituteNode(hint, node, emitCallback) {
+         *     // perform substitution if necessary...
+         *     emitCallback(hint, node);
+         *   }
+         * });
+         * ```
+         */
+        onSubstituteNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
         /*@internal*/ onEmitSourceMapOfNode?: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
         /*@internal*/ onEmitSourceMapOfToken?: (node: Node, token: SyntaxKind, pos: number, emitCallback: (token: SyntaxKind, pos: number) => number) => number;
         /*@internal*/ onEmitSourceMapOfPosition?: (pos: number) => void;

From 1f92bacdc81e7ae6706ad8776121e1db986a8b27 Mon Sep 17 00:00:00 2001
From: Mohamed Hegazy <mhegazy@microsoft.com>
Date: Wed, 1 Feb 2017 22:08:08 -0800
Subject: [PATCH 157/159] Update AUTHORS for release-2.2

---
 .mailmap   | 14 +++++++++++++-
 AUTHORS.md | 12 ++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/.mailmap b/.mailmap
index ede478c8a18..6a9362f6e4c 100644
--- a/.mailmap
+++ b/.mailmap
@@ -8,11 +8,14 @@ Alexander Rusakov  <a_s_rusakov@mail.ru>
 Alex Eagle <alexeagle@google.com>
 Anatoly Ressin  <anatoly.ressin@icloud.com>
 Anders Hejlsberg <andersh@microsoft.com> unknown <andersh@AndersX1.NOE.Nokia.com> unknown <andersh@andersh-yoga.redmond.corp.microsoft.com>
+about-code  <about-code@users.noreply.github.com> # Andreas Martin
 Andrej Baran  <andrej.baran@gmail.com>
+Andrew Ochsner  <andrew.ochsner@wipro.com>
 Andrew Z Allen <me@andrewzallen.com>
 Andy Hanson <anhans@microsoft.com> Andy <anhans@microsoft.com>
 Anil Anar <anilanar@hotmail.com>
 Anton Tolmachev <myste@mail.ru>
+Anubha Mathur  <anubmat@microsoft.com> anubmat  <anubmat@microsoft.com>
 Arnavion <arnavion@gmail.com> # Arnav Singh
 Arthur Ozga <aozgaa@umich.edu> Arthur Ozga <t-arthoz@microsoft.com> Arthur Ozga  <aozgaa-ms@outlook.com> Arthur Ozga  <aozgaa@users.noreply.github.com> Arthur Ozga  <arozga@microsoft.com>
 Asad Saeeduddin <masaeedu@gmail.com>
@@ -37,6 +40,7 @@ Dan Corder <dev@dancorder.com>
 Dan Quirk <danquirk@microsoft.com> Dan Quirk <danquirk@users.noreply.github.com> nknown <danquirk@DANQUIRK1.redmond.corp.microsoft.com>
 Daniel Rosenwasser <drosen@microsoft.com> Daniel Rosenwasser <DanielRosenwasser@users.noreply.github.com> Daniel Rosenwasser <DanielRosenwasser@gmail.com> Daniel Rosenwasser <Daniel.Rosenwasser@microsoft.com> Daniel Rosenwasser <DanielRosenwasser@microsoft.com>
 David Li <jiawei.davidli@gmail.com>
+David Sheldrick  <david@futurice.com>
 David Souther <davidsouther@gmail.com>
 Denis Nedelyaev <denvned@gmail.com>
 Dick van den Brink <d_vandenbrink@outlook.com> unknown <d_vandenbrink@outlook.com> unknown <d_vandenbrink@live.com>
@@ -52,6 +56,7 @@ Evan Sebastian <evanlhoini@gmail.com>
 Eyas <eyas.sharaiha@gmail.com> # Eyas Sharaiha
 Fabian Cook  <faybecook@gmail.com>
 falsandtru <falsandtru@users.noreply.github.com> # @falsandtru
+flowmemo  <flowmemo@outlook.com> # @flowmemo
 Frank Wallis <fwallis@outlook.com>
 František Žiacik <fziacik@gratex.com> František Žiacik <ziacik@gmail.com>
 Gabe Moothart  <gmoothart@gmail.com>
@@ -62,6 +67,7 @@ Graeme Wicksted <graeme.wicksted@gmail.com>
 Guillaume Salles <guillaume.salles@me.com>
 Guy Bedford <guybedford@gmail.com> guybedford <guybedford@gmail.com>
 Harald Niesche <harald@niesche.de>
+Homa Wong  <homawong@gmail.com>
 Iain Monro <iain.monro@softwire.com>
 Ingvar Stepanyan <me@rreverser.com>
 impinball <impinball@gmail.com> # Isiah Meadows
@@ -81,6 +87,7 @@ Jonathan Park <jpark@daptiv.com>
 Jonathan Turner <jont@microsoft.com> Jonathan Turner <probata@hotmail.com>
 Jonathan Toland <toland@dnalot.com>
 Jesse Schalken <me@jesseschalken.com>
+Joel Day  <joelday@gmail.com>
 Josh Abernathy  <joshaber@gmail.com> joshaber  <joshaber@gmail.com>
 Josh Kalderimis <josh.kalderimis@gmail.com>
 Josh Soref <jsoref@users.noreply.github.com>
@@ -95,10 +102,12 @@ Kanchalai Tanglertsampan <yuisu@microsoft.com> Yui T <yuisu@microsoft.com>
 Kanchalai Tanglertsampan <yuisu@microsoft.com> Yui <yuit@users.noreply.github.com>
 Kanchalai Tanglertsampan <yuisu@microsoft.com> Yui <yuisu@microsoft.com>
 Kanchalai Tanglertsampan <yuisu@microsoft.com> yui T <yuisu@microsoft.com>
+Kārlis Gaņģis <Knagis@users.noreply.github.com>
 Keith Mashinter <kmashint@yahoo.com> kmashint <kmashint@yahoo.com>
 Ken Howard <ken@simplicatedweb.com>
 Kevin Lang  <klang2012@gmail.com>
 kimamula <kenji.imamula@gmail.com> # Kenji Imamula
+Klaus Meinhardt  <klaus.meinhardt1@gmail.com>
 Kyle Kelley <rgbkrk@gmail.com>
 Lorant Pinter <lorant.pinter@prezi.com>
 Lucien Greathouse <me@lpghatguy.com>
@@ -107,6 +116,7 @@ Martin Vseticka <vseticka.martin@gmail.com> Martin Všeticka <vseticka.martin@gm
 gcnew  <gcnew@abv.bg> # Marin Marinov
 vvakame <vvakame+dev@gmail.com> # Masahiro Wakame
 Matt McCutchen <rmccutch@mit.edu>
+MANISH-GIRI  <manish.giri.me@gmail.com> # Manish Giri
 Max Deepfield <maxdeepfield@absolutefreakout.com>
 Micah Zoltu <micah@zoltu.net>
 Michael  <maykelchiche@gmail.com>
@@ -213,4 +223,6 @@ Tim Perry <tim.perry@softwire.com>
 Vidar Tonaas Fauske <vidartf@gmail.com>
 Viktor Zozulyak <zozulyakviktor@gmail.com>
 rix <rix@rixs-MacBook-Pro.local> # Richard Sentino
-rohitverma007 <rohitverma@live.ca> # Rohit Verma
\ No newline at end of file
+rohitverma007 <rohitverma@live.ca> # Rohit Verma
+rdosanjh  <me@rajdeep.io> # Raj Dosanjh
+gdh1995  <gdh1995@qq.com> # Dahan Gong
\ No newline at end of file
diff --git a/AUTHORS.md b/AUTHORS.md
index ae7832176ea..196f5e84542 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -12,13 +12,16 @@ TypeScript is authored by:
 * Aliaksandr Radzivanovich
 * Anatoly Ressin 
 * Anders Hejlsberg
+* Andreas Martin
 * Andrej Baran 
+* Andrew Ochsner 
 * Andrew Z Allen
 * András Parditka 
 * Andy Hanson
 * Anil Anar
 * Anton Khlynovskiy 
 * Anton Tolmachev
+* Anubha Mathur 
 * Arnav Singh
 * Arthur Ozga
 * Asad Saeeduddin
@@ -42,12 +45,14 @@ TypeScript is authored by:
 * Cotton Hou 
 * Cyrus Najmabadi
 * Dafrok Zhang
+* Dahan Gong
 * Dan Corder
 * Dan Quirk
 * Daniel Hollocher
 * Daniel Rosenwasser
 * David Kmenta
 * David Li
+* David Sheldrick 
 * David Souther
 * Denis Nedelyaev
 * Dick van den Brink
@@ -66,6 +71,7 @@ TypeScript is authored by:
 * Eyas Sharaiha
 * Fabian Cook 
 * @falsandtru
+* @flowmemo
 * Frank Wallis
 * Franklin Tse
 * František Žiacik
@@ -79,6 +85,7 @@ TypeScript is authored by:
 * Guy Bedford
 * Harald Niesche
 * Herrington Darkholme
+* Homa Wong 
 * Iain Monro
 * Ingvar Stepanyan
 * Isiah Meadows
@@ -93,6 +100,7 @@ TypeScript is authored by:
 * Jeffrey Morlan
 * Jesse Schalken
 * Jiri Tobisek
+* Joel Day 
 * Joey Wilson
 * Johannes Rieken
 * John Vilk
@@ -114,10 +122,13 @@ TypeScript is authored by:
 * Ken Howard
 * Kenji Imamula
 * Kevin Lang 
+* Klaus Meinhardt 
 * Kyle Kelley
+* Kārlis Gaņģis
 * Lorant Pinter
 * Lucien Greathouse
 * Lukas Elmer 
+* Manish Giri
 * Marin Marinov
 * Marius Schulz 
 * Martin Vseticka
@@ -155,6 +166,7 @@ TypeScript is authored by:
 * @progre
 * Punya Biswal
 * Rado Kirov
+* Raj Dosanjh
 * Richard Knoll
 * Richard Sentino
 * Robert Coie

From 6c56b3d957d43dd180f72f6f4af430c10da6c2e7 Mon Sep 17 00:00:00 2001
From: Zhengbo Li <zhengbli@microsoft.com>
Date: Thu, 2 Feb 2017 02:17:49 -0800
Subject: [PATCH 158/159] Fix casing in import quick fix

---
 src/services/codefixes/importFixes.ts         | 31 +++++++------------
 .../importNameCodeFixNewImportFile1.ts        |  4 +--
 2 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 49b8526a1e0..3642e46612c 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -416,8 +416,8 @@ namespace ts.codefix {
                     );
 
                     function getModuleSpecifierForNewImport() {
-                        const fileName = sourceFile.path;
-                        const moduleFileName = moduleSymbol.valueDeclaration.getSourceFile().path;
+                        const fileName = sourceFile.fileName;
+                        const moduleFileName = moduleSymbol.valueDeclaration.getSourceFile().fileName;
                         const sourceDirectory = getDirectoryPath(fileName);
                         const options = context.program.getCompilerOptions();
 
@@ -439,8 +439,7 @@ namespace ts.codefix {
                                 return undefined;
                             }
 
-                            const normalizedBaseUrl = toPath(options.baseUrl, getDirectoryPath(options.baseUrl), getCanonicalFileName);
-                            let relativeName = tryRemoveParentDirectoryName(moduleFileName, normalizedBaseUrl);
+                            let relativeName = getRelativePathIfInDirectory(moduleFileName, options.baseUrl);
                             if (!relativeName) {
                                 return undefined;
                             }
@@ -477,9 +476,8 @@ namespace ts.codefix {
 
                         function tryGetModuleNameFromRootDirs() {
                             if (options.rootDirs) {
-                                const normalizedRootDirs = map(options.rootDirs, rootDir => toPath(rootDir, /*basePath*/ undefined, getCanonicalFileName));
-                                const normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, normalizedRootDirs);
-                                const normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, normalizedRootDirs);
+                                const normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, options.rootDirs);
+                                const normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, options.rootDirs);
                                 if (normalizedTargetPath !== undefined) {
                                     const relativePath = normalizedSourcePath !== undefined ? getRelativePath(normalizedTargetPath, normalizedSourcePath) : normalizedTargetPath;
                                     return removeFileExtension(relativePath);
@@ -546,9 +544,9 @@ namespace ts.codefix {
                         }
                     }
 
-                    function getPathRelativeToRootDirs(path: Path, rootDirs: Path[]) {
+                    function getPathRelativeToRootDirs(path: string, rootDirs: string[]) {
                         for (const rootDir of rootDirs) {
-                            const relativeName = tryRemoveParentDirectoryName(path, rootDir);
+                            const relativeName = getRelativePathIfInDirectory(path, rootDir);
                             if (relativeName !== undefined) {
                                 return relativeName;
                             }
@@ -564,20 +562,15 @@ namespace ts.codefix {
                         return fileName;
                     }
 
+                    function getRelativePathIfInDirectory(path: string, directoryPath: string) {
+                        const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false);
+                        return isRootedDiskPath(relativePath) || startsWith(relativePath, "..") ? undefined : relativePath;
+                    }
+
                     function getRelativePath(path: string, directoryPath: string) {
                         const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false);
                         return moduleHasNonRelativeName(relativePath) ? "./" + relativePath : relativePath;
                     }
-
-                    function tryRemoveParentDirectoryName(path: Path, parentDirectory: Path) {
-                        const index = path.indexOf(parentDirectory);
-                        if (index === 0) {
-                            return endsWith(parentDirectory, directorySeparator)
-                                ? path.substring(parentDirectory.length)
-                                : path.substring(parentDirectory.length + 1);
-                        }
-                        return undefined;
-                    }
                 }
 
             }
diff --git a/tests/cases/fourslash/importNameCodeFixNewImportFile1.ts b/tests/cases/fourslash/importNameCodeFixNewImportFile1.ts
index 0223d96e018..9f6cac0b7c1 100644
--- a/tests/cases/fourslash/importNameCodeFixNewImportFile1.ts
+++ b/tests/cases/fourslash/importNameCodeFixNewImportFile1.ts
@@ -3,7 +3,7 @@
 //// [|/// <reference path="./tripleSlashReference.ts" />
 //// f1/*0*/();|]
 
-// @Filename: module.ts
+// @Filename: Module.ts
 //// export function f1() {}
 //// export var v1 = 5;
 
@@ -12,7 +12,7 @@
 
 verify.importFixAtPosition([
 `/// <reference path="./tripleSlashReference.ts" />
-import { f1 } from "./module";
+import { f1 } from "./Module";
 
 f1();`
 ]);
\ No newline at end of file

From 2f49eeca26a228ce9f9bce849198d1a2c2efc182 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 2 Feb 2017 08:29:00 -0800
Subject: [PATCH 159/159] Remove useless test file

---
 tests/cases/fourslash/goToDefinitionFoo.ts | 6 ------
 1 file changed, 6 deletions(-)
 delete mode 100644 tests/cases/fourslash/goToDefinitionFoo.ts

diff --git a/tests/cases/fourslash/goToDefinitionFoo.ts b/tests/cases/fourslash/goToDefinitionFoo.ts
deleted file mode 100644
index 3e05ee20ecb..00000000000
--- a/tests/cases/fourslash/goToDefinitionFoo.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-////function /*def*/f() {}
-/////*use*/f(123);
-
-verify.goToDefinition("use", "def");