diff --git a/.travis.yml b/.travis.yml
index 5d6663ad6d6..7231d89d354 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,12 +18,12 @@ branches:
   - master
   - release-2.1
   - release-2.2
+  - release-2.3
 
 install:
   - npm uninstall typescript
   - npm uninstall tslint
   - npm install
-  - npm update
 
 cache:
   directories:
diff --git a/Gulpfile.ts b/Gulpfile.ts
index 502846bcaf9..32fbf2c43e0 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -41,6 +41,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
     boolean: ["debug", "inspect", "light", "colors", "lint", "soft"],
     string: ["browser", "tests", "host", "reporter", "stackTraceLimit"],
     alias: {
+        b: "browser",
         d: "debug",
         t: "tests",
         test: "tests",
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 4e6a7a87afa..b2ad2151bb6 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -2298,7 +2298,7 @@ namespace ts {
 
         function isNameOfExportsOrModuleExportsAliasDeclaration(node: Node) {
             if (node.kind === SyntaxKind.Identifier) {
-                const symbol = container.locals.get((<Identifier>node).text);
+                const symbol = lookupSymbolForName((<Identifier>node).text);
                 if (symbol && symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.VariableDeclaration) {
                     const declaration = symbol.valueDeclaration as VariableDeclaration;
                     if (declaration.initializer) {
@@ -2400,8 +2400,12 @@ namespace ts {
             }
         }
 
+        function lookupSymbolForName(name: string) {
+            return (container.symbol && container.symbol.exports && container.symbol.exports.get(name)) || container.locals.get(name);
+        }
+
         function bindPropertyAssignment(functionName: string, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) {
-            let targetSymbol = container.locals.get(functionName);
+            let targetSymbol = lookupSymbolForName(functionName);
 
             if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {
                 targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5d7814f59f7..37163e9e882 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -81,6 +81,7 @@ namespace ts {
             isUndefinedSymbol: symbol => symbol === undefinedSymbol,
             isArgumentsSymbol: symbol => symbol === argumentsSymbol,
             isUnknownSymbol: symbol => symbol === unknownSymbol,
+            getMergedSymbol,
             getDiagnostics,
             getGlobalDiagnostics,
             getTypeOfSymbolAtLocation: (symbol, location) => {
@@ -172,6 +173,17 @@ namespace ts {
                 node = getParseTreeNode(node, isFunctionLike);
                 return node ? isImplementationOfOverload(node) : undefined;
             },
+            getImmediateAliasedSymbol: symbol => {
+                Debug.assert((symbol.flags & SymbolFlags.Alias) !== 0, "Should only get Alias here.");
+                const links = getSymbolLinks(symbol);
+                if (!links.immediateTarget) {
+                    const node = getDeclarationOfAliasSymbol(symbol);
+                    Debug.assert(!!node);
+                    links.immediateTarget = getTargetOfAliasDeclaration(node, /*dontRecursivelyResolve*/ true);
+                }
+
+                return links.immediateTarget;
+            },
             getAliasedSymbol: resolveAlias,
             getEmitResolver,
             getExportsOfModule: getExportsOfModuleAsArray,
@@ -1056,7 +1068,8 @@ namespace ts {
                         !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
                         !checkAndReportErrorForExtendingInterface(errorLocation) &&
                         !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
-                        !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning)) {
+                        !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
+                        !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning))  {
                         error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
                     }
                 }
@@ -1200,6 +1213,24 @@ namespace ts {
             return false;
         }
 
+        function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: string, meaning: SymbolFlags): boolean {
+            if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) {
+                const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined));
+                if (symbol) {
+                    error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_value, name);
+                    return true;
+                }
+            }
+            else if (meaning & (SymbolFlags.Type & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Value)) {
+                const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Type, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined));
+                if (symbol) {
+                    error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_type, name);
+                    return true;
+                }
+            }
+            return false;
+        }
+
         function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
             Debug.assert(!!(result.flags & SymbolFlags.BlockScopedVariable || result.flags & SymbolFlags.Class || result.flags & SymbolFlags.Enum));
             // Block-scoped variables cannot be used before their definition
@@ -1253,14 +1284,14 @@ namespace ts {
             return find<Declaration>(symbol.declarations, isAliasSymbolDeclaration);
         }
 
-        function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
+        function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration, dontResolveAlias: boolean): Symbol {
             if (node.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
                 return resolveExternalModuleSymbol(resolveExternalModuleName(node, getExternalModuleImportEqualsDeclarationExpression(node)));
             }
-            return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>node.moduleReference);
+            return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>node.moduleReference, dontResolveAlias);
         }
 
-        function getTargetOfImportClause(node: ImportClause): Symbol {
+        function getTargetOfImportClause(node: ImportClause, dontResolveAlias: boolean): Symbol {
             const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
 
             if (moduleSymbol) {
@@ -1272,22 +1303,22 @@ namespace ts {
                     const exportValue = moduleSymbol.exports.get("export=");
                     exportDefaultSymbol = exportValue
                         ? getPropertyOfType(getTypeOfSymbol(exportValue), "default")
-                        : resolveSymbol(moduleSymbol.exports.get("default"));
+                        : resolveSymbol(moduleSymbol.exports.get("default"), dontResolveAlias);
                 }
 
                 if (!exportDefaultSymbol && !allowSyntheticDefaultImports) {
                     error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
                 }
                 else if (!exportDefaultSymbol && allowSyntheticDefaultImports) {
-                    return resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    return resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                 }
                 return exportDefaultSymbol;
             }
         }
 
-        function getTargetOfNamespaceImport(node: NamespaceImport): Symbol {
+        function getTargetOfNamespaceImport(node: NamespaceImport, dontResolveAlias: boolean): Symbol {
             const moduleSpecifier = (<ImportDeclaration>node.parent.parent).moduleSpecifier;
-            return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier);
+            return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier, dontResolveAlias);
         }
 
         // This function creates a synthetic symbol that combines the value side of one symbol with the
@@ -1321,12 +1352,9 @@ namespace ts {
             return result;
         }
 
-        function getExportOfModule(symbol: Symbol, name: string): Symbol {
+        function getExportOfModule(symbol: Symbol, name: string, dontResolveAlias: boolean): Symbol {
             if (symbol.flags & SymbolFlags.Module) {
-                const exportedSymbol = getExportsOfSymbol(symbol).get(name);
-                if (exportedSymbol) {
-                    return resolveSymbol(exportedSymbol);
-                }
+                return resolveSymbol(getExportsOfSymbol(symbol).get(name), dontResolveAlias);
             }
         }
 
@@ -1339,9 +1367,9 @@ namespace ts {
             }
         }
 
-        function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier): Symbol {
+        function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier, dontResolveAlias?: boolean): Symbol {
             const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
-            const targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier);
+            const targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier, dontResolveAlias);
             if (targetSymbol) {
                 const name = specifier.propertyName || specifier.name;
                 if (name.text) {
@@ -1358,11 +1386,11 @@ namespace ts {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
                     }
                     // if symbolFromVariable is export - get its final target
-                    symbolFromVariable = resolveSymbol(symbolFromVariable);
-                    let symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
+                    let symbolFromModule = getExportOfModule(targetSymbol, name.text, dontResolveAlias);
                     // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
                     if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") {
-                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                     }
                     const symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
@@ -1375,45 +1403,46 @@ namespace ts {
             }
         }
 
-        function getTargetOfImportSpecifier(node: ImportSpecifier): Symbol {
-            return getExternalModuleMember(<ImportDeclaration>node.parent.parent.parent, node);
+        function getTargetOfImportSpecifier(node: ImportSpecifier, dontResolveAlias: boolean): Symbol {
+            return getExternalModuleMember(<ImportDeclaration>node.parent.parent.parent, node, dontResolveAlias);
         }
 
-        function getTargetOfNamespaceExportDeclaration(node: NamespaceExportDeclaration): Symbol {
-            return resolveExternalModuleSymbol(node.parent.symbol);
+        function getTargetOfNamespaceExportDeclaration(node: NamespaceExportDeclaration, dontResolveAlias: boolean): Symbol {
+            return resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias);
         }
 
-        function getTargetOfExportSpecifier(node: ExportSpecifier): Symbol {
+        function getTargetOfExportSpecifier(node: ExportSpecifier, dontResolveAlias?: boolean): Symbol {
             return (<ExportDeclaration>node.parent.parent).moduleSpecifier ?
-                getExternalModuleMember(<ExportDeclaration>node.parent.parent, node) :
-                resolveEntityName(node.propertyName || node.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+                getExternalModuleMember(<ExportDeclaration>node.parent.parent, node, dontResolveAlias) :
+                resolveEntityName(node.propertyName || node.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
         }
 
-        function getTargetOfExportAssignment(node: ExportAssignment): Symbol {
-            return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+        function getTargetOfExportAssignment(node: ExportAssignment, dontResolveAlias: boolean): Symbol {
+            return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
         }
 
-        function getTargetOfAliasDeclaration(node: Declaration): Symbol {
+        function getTargetOfAliasDeclaration(node: Declaration, dontRecursivelyResolve?: boolean): Symbol {
             switch (node.kind) {
                 case SyntaxKind.ImportEqualsDeclaration:
-                    return getTargetOfImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                    return getTargetOfImportEqualsDeclaration(<ImportEqualsDeclaration>node, dontRecursivelyResolve);
                 case SyntaxKind.ImportClause:
-                    return getTargetOfImportClause(<ImportClause>node);
+                    return getTargetOfImportClause(<ImportClause>node, dontRecursivelyResolve);
                 case SyntaxKind.NamespaceImport:
-                    return getTargetOfNamespaceImport(<NamespaceImport>node);
+                    return getTargetOfNamespaceImport(<NamespaceImport>node, dontRecursivelyResolve);
                 case SyntaxKind.ImportSpecifier:
-                    return getTargetOfImportSpecifier(<ImportSpecifier>node);
+                    return getTargetOfImportSpecifier(<ImportSpecifier>node, dontRecursivelyResolve);
                 case SyntaxKind.ExportSpecifier:
-                    return getTargetOfExportSpecifier(<ExportSpecifier>node);
+                    return getTargetOfExportSpecifier(<ExportSpecifier>node, dontRecursivelyResolve);
                 case SyntaxKind.ExportAssignment:
-                    return getTargetOfExportAssignment(<ExportAssignment>node);
+                    return getTargetOfExportAssignment(<ExportAssignment>node, dontRecursivelyResolve);
                 case SyntaxKind.NamespaceExportDeclaration:
-                    return getTargetOfNamespaceExportDeclaration(<NamespaceExportDeclaration>node);
+                    return getTargetOfNamespaceExportDeclaration(<NamespaceExportDeclaration>node, dontRecursivelyResolve);
             }
         }
 
-        function resolveSymbol(symbol: Symbol): Symbol {
-            return symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) ? resolveAlias(symbol) : symbol;
+        function resolveSymbol(symbol: Symbol, dontResolveAlias?: boolean): Symbol {
+            const shouldResolve = !dontResolveAlias && symbol && symbol.flags & SymbolFlags.Alias && !(symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace));
+            return shouldResolve ? resolveAlias(symbol) : symbol;
         }
 
         function resolveAlias(symbol: Symbol): Symbol {
@@ -1653,16 +1682,16 @@ 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.get("export="))) || moduleSymbol;
+        function resolveExternalModuleSymbol(moduleSymbol: Symbol, dontResolveAlias?: boolean): Symbol {
+            return moduleSymbol && getMergedSymbol(resolveSymbol(moduleSymbol.exports.get("export="), dontResolveAlias)) || moduleSymbol;
         }
 
         // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export ='
         // references a symbol that is at least declared as a module or a variable. The target of the 'export =' may
         // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable).
-        function resolveESModuleSymbol(moduleSymbol: Symbol, moduleReferenceExpression: Expression): Symbol {
-            let symbol = resolveExternalModuleSymbol(moduleSymbol);
-            if (symbol && !(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) {
+        function resolveESModuleSymbol(moduleSymbol: Symbol, moduleReferenceExpression: Expression, dontResolveAlias: boolean): Symbol {
+            let symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
+            if (!dontResolveAlias && symbol && !(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) {
                 error(moduleReferenceExpression, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol));
                 symbol = undefined;
             }
@@ -11067,7 +11096,7 @@ namespace ts {
                     else if (flow.flags & FlowFlags.Start) {
                         // Check if we should continue with the control flow of the containing function.
                         const container = (<FlowStart>flow).container;
-                        if (container && container !== flowContainer && reference.kind !== SyntaxKind.PropertyAccessExpression) {
+                        if (container && container !== flowContainer && reference.kind !== SyntaxKind.PropertyAccessExpression && reference.kind !== SyntaxKind.ThisKeyword) {
                             flow = container.flowNode;
                             continue;
                         }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index e5c623c66f7..17dabdd3ed0 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -887,10 +887,12 @@ namespace ts {
     }
 
     /** Shims `Array.from`. */
-    export function arrayFrom<T>(iterator: Iterator<T>): T[] {
-        const result: T[] = [];
+    export function arrayFrom<T, U>(iterator: Iterator<T>, map: (t: T) => U): U[];
+    export function arrayFrom<T>(iterator: Iterator<T>): T[];
+    export function arrayFrom(iterator: Iterator<any>, map?: (t: any) => any): any[] {
+        const result: any[] = [];
         for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-            result.push(value);
+            result.push(map ? map(value) : value);
         }
         return result;
     }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 075d4247460..10dc25ef70e 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2099,6 +2099,14 @@
         "category": "Error",
         "code": 2707
     },
+    "Cannot use namespace '{0}' as a value.": {
+        "category": "Error",
+        "code": 2708
+    },
+    "Cannot use namespace '{0}' as a type.": {
+        "category": "Error",
+        "code": 2709
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index cf307199da0..5c7486debe3 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -3058,7 +3058,18 @@ namespace ts {
      * @param ensureUseStrict: boolean determining whether the function need to add prologue-directives
      * @param visitor: Optional callback used to visit any custom prologue directives.
      */
-    export function addPrologueDirectives(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult<Node>): number {
+    export function addPrologue(target: Statement[], source: Statement[], ensureUseStrict?: boolean, visitor?: (node: Node) => VisitResult<Node>): number {
+        const offset = addStandardPrologue(target, source, ensureUseStrict);
+        return addCustomPrologue(target, source, offset, visitor);
+    }
+
+    /**
+     * Add just the standard (string-expression) prologue-directives into target statement-array.
+     * The function needs to be called during each transformation step.
+     * This function needs to be called whenever we transform the statement
+     * list of a source file, namespace, or function-like body.
+     */
+    export function addStandardPrologue(target: Statement[], source: Statement[], ensureUseStrict?: boolean): number {
         Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
         let foundUseStrict = false;
         let statementOffset = 0;
@@ -3066,7 +3077,7 @@ namespace ts {
         while (statementOffset < numStatements) {
             const statement = source[statementOffset];
             if (isPrologueDirective(statement)) {
-                if (isUseStrictPrologue(statement as ExpressionStatement)) {
+                if (isUseStrictPrologue(statement)) {
                     foundUseStrict = true;
                 }
                 target.push(statement);
@@ -3079,6 +3090,17 @@ namespace ts {
         if (ensureUseStrict && !foundUseStrict) {
             target.push(startOnNewLine(createStatement(createLiteral("use strict"))));
         }
+        return statementOffset;
+    }
+
+    /**
+     * Add just the custom prologue-directives into target statement-array.
+     * The function needs to be called during each transformation step.
+     * This function needs to be called whenever we transform the statement
+     * list of a source file, namespace, or function-like body.
+     */
+    export function addCustomPrologue(target: Statement[], source: Statement[], statementOffset: number, visitor?: (node: Node) => VisitResult<Node>): number {
+        const numStatements = source.length;
         while (statementOffset < numStatements) {
             const statement = source[statementOffset];
             if (getEmitFlags(statement) & EmitFlags.CustomPrologue) {
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index f76b1a071f2..08144e79299 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -458,6 +458,7 @@ namespace ts {
         return Parser.parseIsolatedEntityName(text, languageVersion);
     }
 
+    // See also `isExternalOrCommonJsModule` in utilities.ts
     export function isExternalModule(file: SourceFile): boolean {
         return file.externalModuleIndicator !== undefined;
     }
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index 3fd837dea10..f8ecf6bdcff 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -515,8 +515,9 @@ namespace ts {
             const ancestorFacts = enterSubtree(HierarchyFacts.SourceFileExcludes, HierarchyFacts.SourceFileIncludes);
             const statements: Statement[] = [];
             startLexicalEnvironment();
-            const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ false, visitor);
+            let statementOffset = addStandardPrologue(statements, node.statements, /*ensureUseStrict*/ false);
             addCaptureThisForNodeIfNeeded(statements, node);
+            statementOffset = addCustomPrologue(statements, node.statements, statementOffset, visitor);
             addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset));
             addRange(statements, endLexicalEnvironment());
             exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);
@@ -924,13 +925,16 @@ namespace ts {
                 statementOffset = 0;
             }
             else if (constructor) {
-                // Otherwise, try to emit all potential prologue directives first.
-                statementOffset = addPrologueDirectives(statements, constructor.body.statements, /*ensureUseStrict*/ false, visitor);
+                statementOffset = addStandardPrologue(statements, constructor.body.statements, /*ensureUseStrict*/ false);
             }
 
             if (constructor) {
                 addDefaultValueAssignmentsIfNeeded(statements, constructor);
                 addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper);
+                if (!hasSynthesizedSuper) {
+                    // If no super call has been synthesized, emit custom prologue directives.
+                    statementOffset = addCustomPrologue(statements, constructor.body.statements, statementOffset, visitor);
+                }
                 Debug.assert(statementOffset >= 0, "statementOffset not initialized correctly!");
 
             }
@@ -1821,8 +1825,8 @@ namespace ts {
             resumeLexicalEnvironment();
             if (isBlock(body)) {
                 // ensureUseStrict is false because no new prologue-directive should be added.
-                // addPrologueDirectives will simply put already-existing directives at the beginning of the target statement-array
-                statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor);
+                // addStandardPrologue will put already-existing directives at the beginning of the target statement-array
+                statementOffset = addStandardPrologue(statements, body.statements, /*ensureUseStrict*/ false);
             }
 
             addCaptureThisForNodeIfNeeded(statements, node);
@@ -1835,6 +1839,9 @@ namespace ts {
             }
 
             if (isBlock(body)) {
+                // addCustomPrologue puts already-existing directives at the beginning of the target statement-array
+                statementOffset = addCustomPrologue(statements, body.statements, statementOffset, visitor);
+
                 statementsLocation = body.statements;
                 addRange(statements, visitNodes(body.statements, visitor, isStatement, statementOffset));
 
diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts
index 088c57866d0..3bbb3b3123f 100644
--- a/src/compiler/transformers/es2017.ts
+++ b/src/compiler/transformers/es2017.ts
@@ -222,7 +222,7 @@ namespace ts {
 
             if (!isArrowFunction) {
                 const statements: Statement[] = [];
-                const statementOffset = addPrologueDirectives(statements, (<Block>node.body).statements, /*ensureUseStrict*/ false, visitor);
+                const statementOffset = addPrologue(statements, (<Block>node.body).statements, /*ensureUseStrict*/ false, visitor);
                 statements.push(
                     createReturn(
                         createAwaiterHelper(
diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index 83e84e6eab5..b0e8b527820 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -618,7 +618,7 @@ namespace ts {
         function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody {
             resumeLexicalEnvironment();
             const statements: Statement[] = [];
-            const statementOffset = addPrologueDirectives(statements, node.body.statements, /*ensureUseStrict*/ false, visitor);
+            const statementOffset = addPrologue(statements, node.body.statements, /*ensureUseStrict*/ false, visitor);
             appendObjectRestAssignmentsIfNeeded(statements, node);
 
             statements.push(
@@ -663,12 +663,19 @@ namespace ts {
         function transformFunctionBody(node: ArrowFunction): ConciseBody;
         function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody {
             resumeLexicalEnvironment();
-            const leadingStatements = appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node);
+            let statementOffset = 0;
+            const statements: Statement[] = [];
             const body = visitNode(node.body, visitor, isConciseBody);
+            if (isBlock(body)) {
+                statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor);
+            }
+            addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node));
             const trailingStatements = endLexicalEnvironment();
-            if (some(leadingStatements) || some(trailingStatements)) {
+            if (statementOffset > 0 || some(statements) || some(trailingStatements)) {
                 const block = convertToFunctionBody(body, /*multiLine*/ true);
-                return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements));
+                addRange(statements, block.statements.slice(statementOffset));
+                addRange(statements, trailingStatements);
+                return updateBlock(block, setTextRange(createNodeArray(statements), block.statements));
             }
             return body;
         }
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index a9da71de885..286892f9d3b 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -587,7 +587,7 @@ namespace ts {
             // Build the generator
             resumeLexicalEnvironment();
 
-            const statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor);
+            const statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor);
 
             transformAndEmitStatements(body.statements, statementOffset);
 
diff --git a/src/compiler/transformers/module/es2015.ts b/src/compiler/transformers/module/es2015.ts
index 7028e235961..660293e074f 100644
--- a/src/compiler/transformers/module/es2015.ts
+++ b/src/compiler/transformers/module/es2015.ts
@@ -24,7 +24,7 @@ namespace ts {
                 const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(node, compilerOptions);
                 if (externalHelpersModuleName) {
                     const statements: Statement[] = [];
-                    const statementOffset = addPrologueDirectives(statements, node.statements);
+                    const statementOffset = addPrologue(statements, node.statements);
                     append(statements,
                         createImportDeclaration(
                             /*decorators*/ undefined,
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index 4fe7b027e93..d387a1a3a24 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -90,7 +90,7 @@ namespace ts {
 
             const statements: Statement[] = [];
             const ensureUseStrict = compilerOptions.alwaysStrict || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
-            const statementOffset = addPrologueDirectives(statements, node.statements, ensureUseStrict, sourceElementVisitor);
+            const statementOffset = addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor);
 
             if (shouldEmitUnderscoreUnderscoreESModule()) {
                 append(statements, createUnderscoreUnderscoreESModule());
@@ -388,7 +388,7 @@ namespace ts {
             startLexicalEnvironment();
 
             const statements: Statement[] = [];
-            const statementOffset = addPrologueDirectives(statements, node.statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, sourceElementVisitor);
+            const statementOffset = addPrologue(statements, node.statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, sourceElementVisitor);
 
             if (shouldEmitUnderscoreUnderscoreESModule()) {
                 append(statements, createUnderscoreUnderscoreESModule());
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 56341f482ff..cde4fcad57e 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -228,7 +228,7 @@ namespace ts {
 
             // Add any prologue directives.
             const ensureUseStrict = compilerOptions.alwaysStrict || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));
-            const statementOffset = addPrologueDirectives(statements, node.statements, ensureUseStrict, sourceElementVisitor);
+            const statementOffset = addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor);
 
             // var __moduleName = context_1 && context_1.id;
             statements.push(
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 8df760d51c0..18387d82611 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -954,7 +954,7 @@ namespace ts {
             if (ctor.body) {
                 const statements = ctor.body.statements;
                 // add prologue directives to the list (if any)
-                const index = addPrologueDirectives(result, statements, /*ensureUseStrict*/ false, visitor);
+                const index = addPrologue(result, statements, /*ensureUseStrict*/ false, visitor);
                 if (index === statements.length) {
                     // list contains nothing but prologue directives (or empty) - exit
                     return index;
@@ -1707,6 +1707,9 @@ namespace ts {
                 case SyntaxKind.StringKeyword:
                     return createIdentifier("String");
 
+                case SyntaxKind.ObjectKeyword:
+                    return createIdentifier("Object");
+
                 case SyntaxKind.LiteralType:
                     switch ((<LiteralTypeNode>node).literal.kind) {
                         case SyntaxKind.StringLiteral:
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index f871aee0baa..8874fd1a798 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1886,6 +1886,7 @@ namespace ts {
         kind: SyntaxKind.ImportDeclaration;
         parent?: SourceFile | ModuleBlock;
         importClause?: ImportClause;
+        /** If this is not a StringLiteral it will be a grammar error. */
         moduleSpecifier: Expression;
     }
 
@@ -1919,6 +1920,7 @@ namespace ts {
         kind: SyntaxKind.ExportDeclaration;
         parent?: SourceFile | ModuleBlock;
         exportClause?: NamedExports;
+        /** If this is not a StringLiteral it will be a grammar error. */
         moduleSpecifier?: Expression;
     }
 
@@ -2305,8 +2307,8 @@ namespace ts {
         // Content of this field should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead
         /* @internal */ resolvedModules: Map<ResolvedModuleFull>;
         /* @internal */ resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective>;
-        /* @internal */ imports: LiteralExpression[];
-        /* @internal */ moduleAugmentations: LiteralExpression[];
+        /* @internal */ imports: StringLiteral[];
+        /* @internal */ moduleAugmentations: StringLiteral[];
         /* @internal */ patternAmbientModules?: PatternAmbientModule[];
         /* @internal */ ambientModuleNames: string[];
         /* @internal */ checkJsDirective: CheckJsDirective | undefined;
@@ -2522,10 +2524,14 @@ namespace ts {
         isUndefinedSymbol(symbol: Symbol): boolean;
         isArgumentsSymbol(symbol: Symbol): boolean;
         isUnknownSymbol(symbol: Symbol): boolean;
+        /* @internal */ getMergedSymbol(symbol: Symbol): Symbol;
 
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
+        /** Follow all aliases to get the original symbol. */
         getAliasedSymbol(symbol: Symbol): Symbol;
+        /** Follow a *single* alias to get the immediately aliased symbol. */
+        /* @internal */ getImmediateAliasedSymbol(symbol: Symbol): Symbol;
         getExportsOfModule(moduleSymbol: Symbol): Symbol[];
         /** Unlike `getExportsOfModule`, this includes properties of an `export =` value. */
         /* @internal */ getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[];
@@ -2841,6 +2847,7 @@ namespace ts {
 
     /* @internal */
     export interface SymbolLinks {
+        immediateTarget?: Symbol;           // Immediate target of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead.
         target?: Symbol;                    // Resolved (non-alias) target of an alias
         type?: Type;                        // Type of value symbol
         declaredType?: Type;                // Type of class, interface, enum, type alias, or type parameter
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 83fe00f0d0b..3b4b87c956f 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3134,7 +3134,7 @@ namespace ts {
         return isExportDefaultSymbol(symbol) ? symbol.valueDeclaration.localSymbol : undefined;
     }
 
-    export function isExportDefaultSymbol(symbol: Symbol): boolean {
+    function isExportDefaultSymbol(symbol: Symbol): boolean {
         return symbol && symbol.valueDeclaration && hasModifier(symbol.valueDeclaration, ModifierFlags.Default);
     }
 
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 5ed1162bd93..c0e950c4f38 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -549,10 +549,21 @@ namespace FourSlash {
                 Harness.IO.log("Unexpected error(s) found.  Error list is:");
             }
 
-            errors.forEach(function (error: ts.Diagnostic) {
-                Harness.IO.log("  minChar: " + error.start +
-                    ", limChar: " + (error.start + error.length) +
-                    ", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n");
+            for (const { start, length, messageText } of errors) {
+                Harness.IO.log("  minChar: " + start +
+                    ", limChar: " + (start + length) +
+                    ", message: " + ts.flattenDiagnosticMessageText(messageText, Harness.IO.newLine()) + "\n");
+            }
+        }
+
+        public verifyNoErrors() {
+            ts.forEachKey(this.inputFiles, fileName => {
+                const errors = this.getDiagnostics(fileName);
+                if (errors.length) {
+                    this.printErrorLog(/*expectErrors*/ false, errors);
+                    const error = errors[0];
+                    this.raiseError(`Found an error: ${error.file.fileName}@${error.start}: ${error.messageText}`);
+                }
             });
         }
 
@@ -882,7 +893,68 @@ namespace FourSlash {
             }
         }
 
-        public verifyReferencesAre(expectedReferences: Range[]) {
+        /** Use `getProgram` instead of accessing this directly. */
+        private _program: ts.Program;
+        /** Use `getChecker` instead of accessing this directly. */
+        private _checker: ts.TypeChecker;
+
+        private getProgram(): ts.Program {
+            return this._program || (this._program = this.languageService.getProgram());
+        }
+
+        private getChecker() {
+            return this._checker || (this._checker = this.getProgram().getTypeChecker());
+        }
+
+        private getSourceFile(): ts.SourceFile {
+            const { fileName } = this.activeFile;
+            const result = this.getProgram().getSourceFile(fileName);
+            if (!result) {
+                throw new Error(`Could not get source file ${fileName}`);
+            }
+            return result;
+        }
+
+        private getNode(): ts.Node {
+            return ts.getTouchingPropertyName(this.getSourceFile(), this.currentCaretPosition);
+        }
+
+        private goToAndGetNode(range: Range): ts.Node {
+            this.goToRangeStart(range);
+            const node = this.getNode();
+            this.verifyRange("touching property name", range, node);
+            return node;
+        }
+
+        private verifyRange(desc: string, expected: Range, actual: ts.Node) {
+            const actualStart = actual.getStart();
+            const actualEnd = actual.getEnd();
+            if (actualStart !== expected.start || actualEnd !== expected.end) {
+                this.raiseError(`${desc} should be ${expected.start}-${expected.end}, got ${actualStart}-${actualEnd}`);
+            }
+        }
+
+        private verifySymbol(symbol: ts.Symbol, declarationRanges: Range[]) {
+            const { declarations } = symbol;
+            if (declarations.length !== declarationRanges.length) {
+                this.raiseError(`Expected to get ${declarationRanges.length} declarations, got ${declarations.length}`);
+            }
+
+            ts.zipWith(declarations, declarationRanges, (decl, range) => {
+                this.verifyRange("symbol declaration", range, decl);
+            });
+        }
+
+        public verifySymbolAtLocation(startRange: Range, declarationRanges: Range[]): void {
+            const node = this.goToAndGetNode(startRange);
+            const symbol = this.getChecker().getSymbolAtLocation(node);
+            if (!symbol) {
+                this.raiseError("Could not get symbol at location");
+            }
+            this.verifySymbol(symbol, declarationRanges);
+        }
+
+        private verifyReferencesAre(expectedReferences: Range[]) {
             const actualReferences = this.getReferencesAtCaret() || [];
 
             if (actualReferences.length > expectedReferences.length) {
@@ -928,7 +1000,7 @@ namespace FourSlash {
 
             for (const startRange of toArray(startRanges)) {
                 this.goToRangeStart(startRange);
-                const fullActual = this.findReferencesAtCaret().map<ReferenceJson>(({ definition, references }) => ({
+                const fullActual = ts.map<ts.ReferencedSymbol, ReferenceJson>(this.findReferencesAtCaret(), ({ definition, references }) => ({
                     definition: definition.displayParts.map(d => d.text).join(""),
                     ranges: references
                 }));
@@ -1108,9 +1180,32 @@ namespace FourSlash {
             });
         }
 
-        public verifyRenameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]) {
-            const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
-            if (renameInfo.canRename) {
+        public verifyRangesAreRenameLocations(options?: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: Range[] }) {
+            const ranges = ts.isArray(options) ? options : options && options.ranges || this.getRanges();
+            this.verifyRenameLocations(ranges, { ranges, ...options });
+        }
+
+        public verifyRenameLocations(startRanges: Range | Range[], options: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: Range[] }) {
+            let findInStrings: boolean, findInComments: boolean, ranges: Range[];
+            if (ts.isArray(options)) {
+                findInStrings = findInComments = false;
+                ranges = options;
+            }
+            else {
+                findInStrings = !!options.findInStrings;
+                findInComments = !!options.findInComments;
+                ranges = options.ranges;
+            }
+
+            for (const startRange of toArray(startRanges)) {
+                this.goToRangeStart(startRange);
+
+                const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
+                if (!renameInfo.canRename) {
+                    this.raiseError("Expected rename to succeed, but it actually failed.");
+                    break;
+                }
+
                 let references = this.languageService.findRenameLocations(
                     this.activeFile.fileName, this.currentCaretPosition, findInStrings, findInComments);
 
@@ -1132,13 +1227,10 @@ namespace FourSlash {
 
                 ts.zipWith(references, ranges, (reference, range) => {
                     if (reference.textSpan.start !== range.start || ts.textSpanEnd(reference.textSpan) !== range.end) {
-                        this.raiseError("Rename location results do not match.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + JSON.stringify(references));
+                        this.raiseError("Rename location results do not match.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + stringify(references));
                     }
                 });
             }
-            else {
-                this.raiseError("Expected rename to succeed, but it actually failed.");
-            }
         }
 
         public verifyQuickInfoExists(negative: boolean) {
@@ -2551,8 +2643,8 @@ namespace FourSlash {
             }
         }
 
-        public verifyRangesAreRenameLocations(findInStrings: boolean, findInComments: boolean) {
-            this.goToEachRange(() => this.verifyRenameLocations(findInStrings, findInComments));
+        public verifyRangesWithSameTextAreRenameLocations() {
+            this.rangesByText().forEach(ranges => this.verifyRangesAreRenameLocations(ranges));
         }
 
         public verifyRangesWithSameTextAreDocumentHighlights() {
@@ -2591,7 +2683,7 @@ namespace FourSlash {
 
                 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}`);
+                        this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${stringify(span.textSpan)}, expected: ${expectedRange.start}--${expectedRange.end}`);
                     }
                 });
             }
@@ -3495,8 +3587,8 @@ namespace FourSlashInterface {
             this.state.verifyGetEmitOutputContentsForCurrentFile(expected);
         }
 
-        public referencesAre(ranges: FourSlash.Range[]) {
-            this.state.verifyReferencesAre(ranges);
+        public symbolAtLocation(startRange: FourSlash.Range, ...declarationRanges: FourSlash.Range[]) {
+            this.state.verifySymbolAtLocation(startRange, declarationRanges);
         }
 
         public referencesOf(start: FourSlash.Range, references: FourSlash.Range[]) {
@@ -3563,6 +3655,10 @@ namespace FourSlashInterface {
             this.state.verifyCurrentSignatureHelpIs(expected);
         }
 
+        public noErrors() {
+            this.state.verifyNoErrors();
+        }
+
         public numberOfErrorsInCurrentFile(expected: number) {
             this.state.verifyNumberOfErrorsInCurrentFile(expected);
         }
@@ -3659,8 +3755,12 @@ namespace FourSlashInterface {
             this.state.verifyRangesAreOccurrences(isWriteAccess);
         }
 
-        public rangesAreRenameLocations(findInStrings = false, findInComments = false) {
-            this.state.verifyRangesAreRenameLocations(findInStrings, findInComments);
+        public rangesWithSameTextAreRenameLocations() {
+            this.state.verifyRangesWithSameTextAreRenameLocations();
+        }
+
+        public rangesAreRenameLocations(options?: FourSlash.Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: FourSlash.Range[] }) {
+            this.state.verifyRangesAreRenameLocations(options);
         }
 
         public rangesAreDocumentHighlights(ranges?: FourSlash.Range[]) {
@@ -3697,8 +3797,8 @@ namespace FourSlashInterface {
             this.state.verifyRenameInfoFailed(message);
         }
 
-        public renameLocations(findInStrings: boolean, findInComments: boolean, ranges?: FourSlash.Range[]) {
-            this.state.verifyRenameLocations(findInStrings, findInComments, ranges);
+        public renameLocations(startRanges: FourSlash.Range | FourSlash.Range[], options: FourSlash.Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: FourSlash.Range[] }) {
+            this.state.verifyRenameLocations(startRanges, options);
         }
 
         public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; },
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index c6477240161..3bf6f1cde9a 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -818,13 +818,17 @@ namespace Harness.LanguageService {
             // This host is just a proxy for the clientHost, it uses the client
             // host to answer server queries about files on disk
             const serverHost = new SessionServerHost(clientHost);
-            const server = new ts.server.Session(serverHost,
-                ts.server.nullCancellationToken,
-                /*useOneInferredProject*/ false,
-                /*typingsInstaller*/ undefined,
-                Utils.byteLength,
-                process.hrtime, serverHost,
-                /*canUseEvents*/ true);
+            const opts: ts.server.SessionOptions = {
+                host: serverHost,
+                cancellationToken: ts.server.nullCancellationToken,
+                useSingleInferredProject: false,
+                typingsInstaller: undefined,
+                byteLength: Utils.byteLength,
+                hrtime: process.hrtime,
+                logger: serverHost,
+                canUseEvents: true
+            };
+            const server = new ts.server.Session(opts);
 
             // Fake the connection between the client and the server
             serverHost.writeMessage = client.onMessage.bind(client);
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index 5389c8f37f8..0725bf36a3b 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -64,8 +64,16 @@ namespace ts {
             getLogFileName: (): string => undefined
         };
 
-        const projectService = new server.ProjectService(serverHost, logger, { isCancellationRequested: () => false }, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined);
-        const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /*openedByClient*/ true, /*containingProject*/ undefined);
+        const svcOpts: server.ProjectServiceOptions = {
+            host: serverHost,
+            logger,
+            cancellationToken: { isCancellationRequested: () => false },
+            useSingleInferredProject: false,
+            typingsInstaller: undefined
+        };
+        const projectService = new server.ProjectService(svcOpts);
+        const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */ true, /*containingProject*/ undefined);
+
         const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo);
         project.setCompilerOptions({ module: ts.ModuleKind.AMD } );
         return {
diff --git a/src/harness/unittests/compileOnSave.ts b/src/harness/unittests/compileOnSave.ts
index 114ee77fef1..506559bd3d9 100644
--- a/src/harness/unittests/compileOnSave.ts
+++ b/src/harness/unittests/compileOnSave.ts
@@ -31,6 +31,20 @@ namespace ts.projectSystem {
             }
         }
 
+        function createSession(host: server.ServerHost, typingsInstaller?: server.ITypingsInstaller): server.Session {
+            const opts: server.SessionOptions = {
+                host,
+                cancellationToken: nullCancellationToken,
+                useSingleInferredProject: false,
+                typingsInstaller: typingsInstaller || server.nullTypingsInstaller,
+                byteLength: Utils.byteLength,
+                hrtime: process.hrtime,
+                logger: nullLogger,
+                canUseEvents: false
+            };
+            return new server.Session(opts);
+        }
+
         describe("for configured projects", () => {
             let moduleFile1: FileOrFolder;
             let file1Consumer1: FileOrFolder;
@@ -113,7 +127,7 @@ namespace ts.projectSystem {
             it("should contains only itself if a module file's shape didn't change, and all files referencing it if its shape changed", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1, file1Consumer1], session);
 
@@ -138,7 +152,7 @@ namespace ts.projectSystem {
             it("should be up-to-date with the reference map changes", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1, file1Consumer1], session);
 
@@ -185,7 +199,7 @@ namespace ts.projectSystem {
             it("should be up-to-date with changes made in non-open files", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1], session);
 
@@ -203,7 +217,7 @@ namespace ts.projectSystem {
             it("should be up-to-date with deleted files", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1], session);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
@@ -218,7 +232,7 @@ namespace ts.projectSystem {
             it("should be up-to-date with newly created files", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1], session);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
@@ -255,7 +269,7 @@ namespace ts.projectSystem {
 
                 const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1, file1Consumer1], session);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]);
@@ -272,7 +286,7 @@ namespace ts.projectSystem {
             it("should return all files if a global file changed shape", () => {
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([globalFile3], session);
                 const changeGlobalFile3ShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
@@ -298,7 +312,7 @@ namespace ts.projectSystem {
 
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
                 openFilesForSession([moduleFile1], session);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, []);
             });
@@ -316,7 +330,7 @@ namespace ts.projectSystem {
 
                 const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
                 openFilesForSession([moduleFile1], session);
 
                 const file1ChangeShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
@@ -345,7 +359,7 @@ namespace ts.projectSystem {
 
                 const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
                 openFilesForSession([moduleFile1], session);
 
                 const file1ChangeShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
@@ -367,7 +381,7 @@ namespace ts.projectSystem {
                 };
                 const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer1Consumer1, globalFile3, configFile, libFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([moduleFile1, file1Consumer1], session);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer1Consumer1] }]);
@@ -400,7 +414,7 @@ namespace ts.projectSystem {
                 };
                 const host = createServerHost([file1, file2, configFile]);
                 const typingsInstaller = createTestTypingsInstaller(host);
-                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                const session = createSession(host, typingsInstaller);
 
                 openFilesForSession([file1, file2], session);
                 const file1AffectedListRequest = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: file1.path });
@@ -513,7 +527,7 @@ namespace ts.projectSystem {
             };
             const host = createServerHost([file1, file2, configFile, libFile], { newLine: "\r\n" });
             const typingsInstaller = createTestTypingsInstaller(host);
-            const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+            const session = createSession(host, typingsInstaller);
 
             openFilesForSession([file1, file2], session);
             const compileFileRequest = makeSessionRequest<server.protocol.CompileOnSaveEmitFileRequestArgs>(CommandNames.CompileOnSaveEmitFile, { file: file1.path, projectFileName: configFile.path });
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index 9a38de7da10..a505c3ee7be 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -50,8 +50,22 @@ namespace ts.server {
         let session: TestSession;
         let lastSent: protocol.Message;
 
+        function createSession(): TestSession {
+            const opts: server.SessionOptions = {
+                host: mockHost,
+                cancellationToken: nullCancellationToken,
+                useSingleInferredProject: false,
+                typingsInstaller: undefined,
+                byteLength: Utils.byteLength,
+                hrtime: process.hrtime,
+                logger: mockLogger,
+                canUseEvents: true
+            };
+            return new TestSession(opts);
+        }
+
         beforeEach(() => {
-            session = new TestSession(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true);
+            session = createSession();
             session.send = (msg: protocol.Message) => {
                 lastSent = msg;
             };
@@ -318,7 +332,16 @@ namespace ts.server {
             lastSent: protocol.Message;
             customHandler = "testhandler";
             constructor() {
-                super(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true);
+                super({
+                    host: mockHost,
+                    cancellationToken: nullCancellationToken,
+                    useSingleInferredProject: false,
+                    typingsInstaller: undefined,
+                    byteLength: Utils.byteLength,
+                    hrtime: process.hrtime,
+                    logger: mockLogger,
+                    canUseEvents: true
+                });
                 this.addProtocolHandler(this.customHandler, () => {
                     return { response: undefined, responseRequired: true };
                 });
@@ -376,7 +399,16 @@ namespace ts.server {
         class InProcSession extends Session {
             private queue: protocol.Request[] = [];
             constructor(private client: InProcClient) {
-                super(mockHost, nullCancellationToken, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined, Utils.byteLength, process.hrtime, mockLogger, /*canUseEvents*/ true);
+                super({
+                    host: mockHost,
+                    cancellationToken: nullCancellationToken,
+                    useSingleInferredProject: false,
+                    typingsInstaller: undefined,
+                    byteLength: Utils.byteLength,
+                    hrtime: process.hrtime,
+                    logger: mockLogger,
+                    canUseEvents: true
+                });
                 this.addProtocolHandler("echo", (req: protocol.Request) => ({
                     response: req.arguments,
                     responseRequired: true
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 8364420709c..81931a2de41 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -190,7 +190,19 @@ namespace ts.projectSystem {
         if (typingsInstaller === undefined) {
             typingsInstaller = new TestTypingsInstaller("/a/data/", /*throttleLimit*/5, host);
         }
-        return new TestSession(host, cancellationToken || server.nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ projectServiceEventHandler !== undefined, projectServiceEventHandler, throttleWaitMilliseconds);
+        const opts: server.SessionOptions = {
+            host,
+            cancellationToken: cancellationToken || server.nullCancellationToken,
+            useSingleInferredProject: false,
+            typingsInstaller,
+            byteLength: Utils.byteLength,
+            hrtime: process.hrtime,
+            logger: nullLogger,
+            canUseEvents: projectServiceEventHandler !== undefined,
+            eventHandler: projectServiceEventHandler,
+            throttleWaitMilliseconds
+        };
+        return new TestSession(opts);
     }
 
     export interface CreateProjectServiceParameters {
@@ -205,7 +217,9 @@ namespace ts.projectSystem {
     export class TestProjectService extends server.ProjectService {
         constructor(host: server.ServerHost, logger: server.Logger, cancellationToken: HostCancellationToken, useSingleInferredProject: boolean,
             typingsInstaller: server.ITypingsInstaller, eventHandler: server.ProjectServiceEventHandler) {
-            super(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler);
+            super({
+                host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler
+            });
         }
 
         checkNumberOfProjects(count: { inferredProjects?: number, configuredProjects?: number, externalProjects?: number }) {
diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
index 348e52246a7..c43c59e3b12 100644
--- a/src/lib/dom.generated.d.ts
+++ b/src/lib/dom.generated.d.ts
@@ -78,8 +78,8 @@ interface ConstrainLongRange extends LongRange {
 }
 
 interface ConstrainVideoFacingModeParameters {
-    exact?: string | string[];
-    ideal?: string | string[];
+    exact?: VideoFacingModeEnum | VideoFacingModeEnum[];
+    ideal?: VideoFacingModeEnum | VideoFacingModeEnum[];
 }
 
 interface CustomEventInit extends EventInit {
@@ -308,7 +308,7 @@ interface MSAudioSendSignal {
 }
 
 interface MSConnectivity {
-    iceType?: string;
+    iceType?: MSIceType;
     iceWarningFlags?: MSIceWarningFlags;
     relayAddress?: MSRelayAddress;
 }
@@ -318,11 +318,11 @@ interface MSCredentialFilter {
 }
 
 interface MSCredentialParameters {
-    type?: string;
+    type?: MSCredentialType;
 }
 
 interface MSCredentialSpec {
-    type?: string;
+    type?: MSCredentialType;
     id?: string;
 }
 
@@ -333,7 +333,7 @@ interface MSDelay {
 
 interface MSDescription extends RTCStats {
     connectivity?: MSConnectivity;
-    transport?: string;
+    transport?: RTCIceProtocol;
     networkconnectivity?: MSNetworkConnectivityInfo;
     localAddr?: MSIPAddressInfo;
     remoteAddr?: MSIPAddressInfo;
@@ -457,11 +457,11 @@ interface MSTransportDiagnosticsStats extends RTCStats {
     numConsentRespReceived?: number;
     interfaces?: MSNetworkInterfaceType;
     baseInterface?: MSNetworkInterfaceType;
-    protocol?: string;
+    protocol?: RTCIceProtocol;
     localInterface?: MSNetworkInterfaceType;
-    localAddrType?: string;
-    remoteAddrType?: string;
-    iceRole?: string;
+    localAddrType?: MSIceAddrType;
+    remoteAddrType?: MSIceAddrType;
+    iceRole?: RTCIceRole;
     rtpRtcpMux?: boolean;
     allocationTimeInMs?: number;
     msRtcEngineVersion?: string;
@@ -534,7 +534,7 @@ interface MediaEncryptedEventInit extends EventInit {
 }
 
 interface MediaKeyMessageEventInit extends EventInit {
-    messageType?: string;
+    messageType?: MediaKeyMessageType;
     message?: ArrayBuffer;
 }
 
@@ -542,8 +542,8 @@ interface MediaKeySystemConfiguration {
     initDataTypes?: string[];
     audioCapabilities?: MediaKeySystemMediaCapability[];
     videoCapabilities?: MediaKeySystemMediaCapability[];
-    distinctiveIdentifier?: string;
-    persistentState?: string;
+    distinctiveIdentifier?: MediaKeysRequirement;
+    persistentState?: MediaKeysRequirement;
 }
 
 interface MediaKeySystemMediaCapability {
@@ -667,7 +667,7 @@ interface MutationObserverInit {
 }
 
 interface NotificationOptions {
-    dir?: string;
+    dir?: NotificationDirection;
     lang?: string;
     body?: string;
     tag?: string;
@@ -766,8 +766,8 @@ interface PushSubscriptionOptionsInit {
 
 interface RTCConfiguration {
     iceServers?: RTCIceServer[];
-    iceTransportPolicy?: string;
-    bundlePolicy?: string;
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    bundlePolicy?: RTCBundlePolicy;
     peerIdentity?: string;
 }
 
@@ -781,7 +781,7 @@ interface RTCDtlsFingerprint {
 }
 
 interface RTCDtlsParameters {
-    role?: string;
+    role?: RTCDtlsRole;
     fingerprints?: RTCDtlsFingerprint[];
 }
 
@@ -789,7 +789,7 @@ interface RTCIceCandidateAttributes extends RTCStats {
     ipAddress?: string;
     portNumber?: number;
     transport?: string;
-    candidateType?: string;
+    candidateType?: RTCStatsIceCandidateType;
     priority?: number;
     addressSourceUrl?: string;
 }
@@ -801,10 +801,10 @@ interface RTCIceCandidateDictionary {
     foundation?: string;
     priority?: number;
     ip?: string;
-    protocol?: string;
+    protocol?: RTCIceProtocol;
     port?: number;
-    type?: string;
-    tcpType?: string;
+    type?: RTCIceCandidateType;
+    tcpType?: RTCIceTcpCandidateType;
     relatedAddress?: string;
     relatedPort?: number;
     msMTurnSessionId?: string;
@@ -825,7 +825,7 @@ interface RTCIceCandidatePairStats extends RTCStats {
     transportId?: string;
     localCandidateId?: string;
     remoteCandidateId?: string;
-    state?: string;
+    state?: RTCStatsIceCandidatePairState;
     priority?: number;
     nominated?: boolean;
     writable?: boolean;
@@ -838,7 +838,7 @@ interface RTCIceCandidatePairStats extends RTCStats {
 }
 
 interface RTCIceGatherOptions {
-    gatherPolicy?: string;
+    gatherPolicy?: RTCIceGatherPolicy;
     iceservers?: RTCIceServer[];
     portRange?: MSPortRange;
 }
@@ -1003,7 +1003,7 @@ interface RTCRtpParameters {
     headerExtensions?: RTCRtpHeaderExtensionParameters[];
     encodings?: RTCRtpEncodingParameters[];
     rtcp?: RTCRtcpParameters;
-    degradationPreference?: string;
+    degradationPreference?: RTCDegradationPreference;
 }
 
 interface RTCRtpRtxParameters {
@@ -1017,7 +1017,7 @@ interface RTCRtpUnhandled {
 }
 
 interface RTCSessionDescriptionInit {
-    type?: string;
+    type?: RTCSdpType;
     sdp?: string;
 }
 
@@ -1043,9 +1043,9 @@ interface RTCSsrcRange {
 
 interface RTCStats {
     timestamp?: number;
-    type?: string;
+    type?: RTCStatsType;
     id?: string;
-    msType?: string;
+    msType?: MSStatsType;
 }
 
 interface RTCStatsReport {
@@ -1070,11 +1070,11 @@ interface RequestInit {
     headers?: any;
     body?: any;
     referrer?: string;
-    referrerPolicy?: string;
-    mode?: string;
-    credentials?: string;
-    cache?: string;
-    redirect?: string;
+    referrerPolicy?: ReferrerPolicy;
+    mode?: RequestMode;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
     integrity?: string;
     keepalive?: boolean;
     window?: any;
@@ -1087,9 +1087,9 @@ interface ResponseInit {
 }
 
 interface ScopedCredentialDescriptor {
-    type?: string;
+    type?: ScopedCredentialType;
     id?: any;
-    transports?: string[];
+    transports?: Transport[];
 }
 
 interface ScopedCredentialOptions {
@@ -1100,7 +1100,7 @@ interface ScopedCredentialOptions {
 }
 
 interface ScopedCredentialParameters {
-    type?: string;
+    type?: ScopedCredentialType;
     algorithm?: string | Algorithm;
 }
 
@@ -1330,7 +1330,7 @@ interface AudioContextBase extends EventTarget {
     readonly listener: AudioListener;
     onstatechange: (this: AudioContext, ev: Event) => any;
     readonly sampleRate: number;
-    readonly state: string;
+    readonly state: AudioContextState;
     close(): Promise<void>;
     createAnalyser(): AnalyserNode;
     createBiquadFilter(): BiquadFilterNode;
@@ -1390,8 +1390,8 @@ declare var AudioListener: {
 
 interface AudioNode extends EventTarget {
     channelCount: number;
-    channelCountMode: string;
-    channelInterpretation: string;
+    channelCountMode: ChannelCountMode;
+    channelInterpretation: ChannelInterpretation;
     readonly context: AudioContext;
     readonly numberOfInputs: number;
     readonly numberOfOutputs: number;
@@ -1494,7 +1494,7 @@ interface BiquadFilterNode extends AudioNode {
     readonly detune: AudioParam;
     readonly frequency: AudioParam;
     readonly gain: AudioParam;
-    type: string;
+    type: BiquadFilterType;
     getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
 }
 
@@ -2134,7 +2134,7 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods {
     lineJoin: string;
     lineWidth: number;
     miterLimit: number;
-    msFillRule: string;
+    msFillRule: CanvasFillRule;
     shadowBlur: number;
     shadowColor: string;
     shadowOffsetX: number;
@@ -2147,7 +2147,7 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods {
     oImageSmoothingEnabled: boolean;
     beginPath(): void;
     clearRect(x: number, y: number, w: number, h: number): void;
-    clip(fillRule?: string): void;
+    clip(fillRule?: CanvasFillRule): void;
     createImageData(imageDataOrSw: number | ImageData, sh?: number): ImageData;
     createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
     createPattern(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, repetition: string): CanvasPattern;
@@ -2156,12 +2156,12 @@ interface CanvasRenderingContext2D extends Object, CanvasPathMethods {
     drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, dstX: number, dstY: number): void;
     drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, dstX: number, dstY: number, dstW: number, dstH: number): void;
     drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap, srcX: number, srcY: number, srcW: number, srcH: number, dstX: number, dstY: number, dstW: number, dstH: number): void;
-    fill(fillRule?: string): void;
+    fill(fillRule?: CanvasFillRule): void;
     fillRect(x: number, y: number, w: number, h: number): void;
     fillText(text: string, x: number, y: number, maxWidth?: number): void;
     getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
     getLineDash(): number[];
-    isPointInPath(x: number, y: number, fillRule?: string): boolean;
+    isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
     measureText(text: string): TextMetrics;
     putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
     restore(): void;
@@ -2538,6 +2538,7 @@ interface DataTransfer {
     clearData(format?: string): boolean;
     getData(format: string): string;
     setData(format: string, data: string): boolean;
+    setDragImage(image: Element, x: number, y: number): void;
 }
 
 declare var DataTransfer: {
@@ -2574,7 +2575,7 @@ declare var DataTransferItemList: {
 
 interface DeferredPermissionRequest {
     readonly id: number;
-    readonly type: string;
+    readonly type: MSWebViewPermissionType;
     readonly uri: string;
     allow(): void;
     deny(): void;
@@ -3192,7 +3193,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
       * Contains the title of the document.
       */
     title: string;
-    readonly visibilityState: string;
+    readonly visibilityState: VisibilityState;
     /** 
       * Sets or gets the color of the links that the user has visited.
       */
@@ -3207,7 +3208,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
       * Gets or sets the version attribute specified in the declaration of an XML document.
       */
     xmlVersion: string | null;
-    adoptNode(source: Node): Node;
+    adoptNode<T extends Node>(source: T): T;
     captureEvents(): void;
     caretRangeFromPoint(x: number, y: number): Range;
     clear(): void;
@@ -3384,7 +3385,7 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
       * Gets a value indicating whether the object currently has focus.
       */
     hasFocus(): boolean;
-    importNode(importedNode: Node, deep: boolean): Node;
+    importNode<T extends Node>(importedNode: T, deep: boolean): T;
     msElementsFromPoint(x: number, y: number): NodeListOf<Element>;
     msElementsFromRect(left: number, top: number, width: number, height: number): NodeListOf<Element>;
     /**
@@ -3700,9 +3701,9 @@ declare var Event: {
 }
 
 interface EventTarget {
-    addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    addEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     dispatchEvent(evt: Event): boolean;
-    removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
 declare var EventTarget: {
@@ -3781,7 +3782,7 @@ declare var FocusEvent: {
 }
 
 interface FocusNavigationEvent extends Event {
-    readonly navigationReason: string;
+    readonly navigationReason: NavigationReason;
     readonly originHeight: number;
     readonly originLeft: number;
     readonly originTop: number;
@@ -3795,7 +3796,12 @@ declare var FocusNavigationEvent: {
 }
 
 interface FormData {
-    append(name: any, value: any, blobName?: string): void;
+    append(name: string, value: string | Blob, fileName?: string): void;
+    delete(name: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    set(name: string, value: string | Blob, fileName?: string): void;
 }
 
 declare var FormData: {
@@ -6957,7 +6963,7 @@ declare var History: {
 }
 
 interface IDBCursor {
-    readonly direction: string;
+    readonly direction: IDBCursorDirection;
     key: IDBKeyRange | IDBValidKey;
     readonly primaryKey: any;
     source: IDBObjectStore | IDBIndex;
@@ -7109,7 +7115,7 @@ interface IDBRequest extends EventTarget {
     readonly error: DOMError;
     onerror: (this: IDBRequest, ev: Event) => any;
     onsuccess: (this: IDBRequest, ev: Event) => any;
-    readonly readyState: string;
+    readonly readyState: IDBRequestReadyState;
     readonly result: any;
     source: IDBObjectStore | IDBIndex | IDBCursor;
     readonly transaction: IDBTransaction;
@@ -7131,7 +7137,7 @@ interface IDBTransactionEventMap {
 interface IDBTransaction extends EventTarget {
     readonly db: IDBDatabase;
     readonly error: DOMError;
-    readonly mode: string;
+    readonly mode: IDBTransactionMode;
     onabort: (this: IDBTransaction, ev: Event) => any;
     oncomplete: (this: IDBTransaction, ev: Event) => any;
     onerror: (this: IDBTransaction, ev: Event) => any;
@@ -7249,7 +7255,7 @@ declare var KeyboardEvent: {
 
 interface ListeningStateChangedEvent extends Event {
     readonly label: string;
-    readonly state: string;
+    readonly state: ListeningState;
 }
 
 declare var ListeningStateChangedEvent: {
@@ -7340,7 +7346,7 @@ declare var MSAppAsyncOperation: {
 
 interface MSAssertion {
     readonly id: string;
-    readonly type: string;
+    readonly type: MSCredentialType;
 }
 
 declare var MSAssertion: {
@@ -7372,7 +7378,7 @@ interface MSFIDOCredentialAssertion extends MSAssertion {
     readonly algorithm: string | Algorithm;
     readonly attestation: any;
     readonly publicKey: string;
-    readonly transportHints: string[];
+    readonly transportHints: MSTransportType[];
 }
 
 declare var MSFIDOCredentialAssertion: {
@@ -7476,7 +7482,7 @@ interface MSHTMLWebViewElement extends HTMLElement {
     goForward(): void;
     invokeScriptAsync(scriptName: string, ...args: any[]): MSWebViewAsyncOperation;
     navigate(uri: string): void;
-    navigateFocus(navigationReason: string, origin: FocusNavigationOrigin): void;
+    navigateFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
     navigateToLocalStreamUri(source: string, streamResolver: any): void;
     navigateToString(contents: string): void;
     navigateWithHttpRequestMessage(requestMessage: any): void;
@@ -7731,7 +7737,7 @@ declare var MSWebViewSettings: {
 interface MediaDeviceInfo {
     readonly deviceId: string;
     readonly groupId: string;
-    readonly kind: string;
+    readonly kind: MediaDeviceKind;
     readonly label: string;
 }
 
@@ -7798,7 +7804,7 @@ declare var MediaError: {
 
 interface MediaKeyMessageEvent extends Event {
     readonly message: ArrayBuffer;
-    readonly messageType: string;
+    readonly messageType: MediaKeyMessageType;
 }
 
 declare var MediaKeyMessageEvent: {
@@ -7826,7 +7832,7 @@ declare var MediaKeySession: {
 interface MediaKeyStatusMap {
     readonly size: number;
     forEach(callback: ForEachCallback): void;
-    get(keyId: any): string;
+    get(keyId: any): MediaKeyStatus;
     has(keyId: any): boolean;
 }
 
@@ -7847,7 +7853,7 @@ declare var MediaKeySystemAccess: {
 }
 
 interface MediaKeys {
-    createSession(sessionType?: string): MediaKeySession;
+    createSession(sessionType?: MediaKeySessionType): MediaKeySession;
     setServerCertificate(serverCertificate: any): Promise<void>;
 }
 
@@ -7985,7 +7991,7 @@ interface MediaStreamTrack extends EventTarget {
     onoverconstrained: (this: MediaStreamTrack, ev: MediaStreamErrorEvent) => any;
     onunmute: (this: MediaStreamTrack, ev: Event) => any;
     readonly readonly: boolean;
-    readonly readyState: string;
+    readonly readyState: MediaStreamTrackState;
     readonly remote: boolean;
     applyConstraints(constraints: MediaTrackConstraints): Promise<void>;
     clone(): MediaStreamTrack;
@@ -8206,7 +8212,7 @@ declare var NavigationEventWithReferrer: {
 interface Navigator extends Object, NavigatorID, NavigatorOnLine, NavigatorContentUtils, NavigatorStorageUtils, NavigatorGeolocation, MSNavigatorDoNotTrack, MSFileSaver, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorUserMedia {
     readonly authentication: WebAuthentication;
     readonly cookieEnabled: boolean;
-    gamepadInputEmulation: string;
+    gamepadInputEmulation: GamepadInputEmulationType;
     readonly language: string;
     readonly maxTouchPoints: number;
     readonly mimeTypes: MimeTypeArray;
@@ -8253,15 +8259,15 @@ interface Node extends EventTarget {
     contains(child: Node): boolean;
     hasAttributes(): boolean;
     hasChildNodes(): boolean;
-    insertBefore(newChild: Node, refChild: Node | null): Node;
+    insertBefore<T extends Node>(newChild: T, refChild: Node | null): T;
     isDefaultNamespace(namespaceURI: string | null): boolean;
     isEqualNode(arg: Node): boolean;
     isSameNode(other: Node): boolean;
     lookupNamespaceURI(prefix: string | null): string | null;
     lookupPrefix(namespaceURI: string | null): string | null;
     normalize(): void;
-    removeChild(oldChild: Node): Node;
-    replaceChild(newChild: Node, oldChild: Node): Node;
+    removeChild<T extends Node>(oldChild: T): T;
+    replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
     readonly ATTRIBUTE_NODE: number;
     readonly CDATA_SECTION_NODE: number;
     readonly COMMENT_NODE: number;
@@ -8363,14 +8369,14 @@ interface NotificationEventMap {
 
 interface Notification extends EventTarget {
     readonly body: string;
-    readonly dir: string;
+    readonly dir: NotificationDirection;
     readonly icon: string;
     readonly lang: string;
     onclick: (this: Notification, ev: Event) => any;
     onclose: (this: Notification, ev: Event) => any;
     onerror: (this: Notification, ev: Event) => any;
     onshow: (this: Notification, ev: Event) => any;
-    readonly permission: string;
+    readonly permission: NotificationPermission;
     readonly tag: string;
     readonly title: string;
     close(): void;
@@ -8381,7 +8387,7 @@ interface Notification extends EventTarget {
 declare var Notification: {
     prototype: Notification;
     new(title: string, options?: NotificationOptions): Notification;
-    requestPermission(callback?: NotificationPermissionCallback): Promise<string>;
+    requestPermission(callback?: NotificationPermissionCallback): Promise<NotificationPermission>;
 }
 
 interface OES_element_index_uint {
@@ -8471,7 +8477,7 @@ interface OscillatorNode extends AudioNode {
     readonly detune: AudioParam;
     readonly frequency: AudioParam;
     onended: (this: OscillatorNode, ev: MediaStreamErrorEvent) => any;
-    type: string;
+    type: OscillatorType;
     setPeriodicWave(periodicWave: PeriodicWave): void;
     start(when?: number): void;
     stop(when?: number): void;
@@ -8514,9 +8520,9 @@ interface PannerNode extends AudioNode {
     coneInnerAngle: number;
     coneOuterAngle: number;
     coneOuterGain: number;
-    distanceModel: string;
+    distanceModel: DistanceModelType;
     maxDistance: number;
-    panningModel: string;
+    panningModel: PanningModelType;
     refDistance: number;
     rolloffFactor: number;
     setOrientation(x: number, y: number, z: number): void;
@@ -8567,7 +8573,7 @@ interface PaymentRequest extends EventTarget {
     onshippingoptionchange: (this: PaymentRequest, ev: Event) => any;
     readonly shippingAddress: PaymentAddress | null;
     readonly shippingOption: string | null;
-    readonly shippingType: string | null;
+    readonly shippingType: PaymentShippingType | null;
     abort(): Promise<void>;
     show(): Promise<PaymentResponse>;
     addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, useCapture?: boolean): void;
@@ -8596,7 +8602,7 @@ interface PaymentResponse {
     readonly payerPhone: string | null;
     readonly shippingAddress: PaymentAddress | null;
     readonly shippingOption: string | null;
-    complete(result?: string): Promise<void>;
+    complete(result?: PaymentComplete): Promise<void>;
     toJSON(): any;
 }
 
@@ -8724,7 +8730,7 @@ interface PerformanceNavigationTiming extends PerformanceEntry {
     readonly requestStart: number;
     readonly responseEnd: number;
     readonly responseStart: number;
-    readonly type: string;
+    readonly type: NavigationType;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
 }
@@ -8793,7 +8799,7 @@ declare var PeriodicWave: {
 }
 
 interface PermissionRequest extends DeferredPermissionRequest {
-    readonly state: string;
+    readonly state: MSWebViewPermissionState;
     defer(): void;
 }
 
@@ -8923,7 +8929,7 @@ declare var ProgressEvent: {
 
 interface PushManager {
     getSubscription(): Promise<PushSubscription>;
-    permissionState(options?: PushSubscriptionOptionsInit): Promise<string>;
+    permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
     subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
 }
 
@@ -8935,7 +8941,7 @@ declare var PushManager: {
 interface PushSubscription {
     readonly endpoint: USVString;
     readonly options: PushSubscriptionOptions;
-    getKey(name: string): ArrayBuffer | null;
+    getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
     toJSON(): any;
     unsubscribe(): Promise<boolean>;
 }
@@ -8972,7 +8978,7 @@ interface RTCDtlsTransportEventMap {
 interface RTCDtlsTransport extends RTCStatsProvider {
     ondtlsstatechange: ((this: RTCDtlsTransport, ev: RTCDtlsTransportStateChangedEvent) => any) | null;
     onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null;
-    readonly state: string;
+    readonly state: RTCDtlsTransportState;
     readonly transport: RTCIceTransport;
     getLocalParameters(): RTCDtlsParameters;
     getRemoteCertificates(): ArrayBuffer[];
@@ -8989,7 +8995,7 @@ declare var RTCDtlsTransport: {
 }
 
 interface RTCDtlsTransportStateChangedEvent extends Event {
-    readonly state: string;
+    readonly state: RTCDtlsTransportState;
 }
 
 declare var RTCDtlsTransportStateChangedEvent: {
@@ -9045,7 +9051,7 @@ interface RTCIceGathererEventMap {
 }
 
 interface RTCIceGatherer extends RTCStatsProvider {
-    readonly component: string;
+    readonly component: RTCIceComponent;
     onerror: ((this: RTCIceGatherer, ev: Event) => any) | null;
     onlocalcandidate: ((this: RTCIceGatherer, ev: RTCIceGathererEvent) => any) | null;
     createAssociatedGatherer(): RTCIceGatherer;
@@ -9075,19 +9081,19 @@ interface RTCIceTransportEventMap {
 }
 
 interface RTCIceTransport extends RTCStatsProvider {
-    readonly component: string;
+    readonly component: RTCIceComponent;
     readonly iceGatherer: RTCIceGatherer | null;
     oncandidatepairchange: ((this: RTCIceTransport, ev: RTCIceCandidatePairChangedEvent) => any) | null;
     onicestatechange: ((this: RTCIceTransport, ev: RTCIceTransportStateChangedEvent) => any) | null;
-    readonly role: string;
-    readonly state: string;
+    readonly role: RTCIceRole;
+    readonly state: RTCIceTransportState;
     addRemoteCandidate(remoteCandidate: RTCIceCandidateDictionary | RTCIceCandidateComplete): void;
     createAssociatedTransport(): RTCIceTransport;
     getNominatedCandidatePair(): RTCIceCandidatePair | null;
     getRemoteCandidates(): RTCIceCandidateDictionary[];
     getRemoteParameters(): RTCIceParameters | null;
     setRemoteCandidates(remoteCandidates: RTCIceCandidateDictionary[]): void;
-    start(gatherer: RTCIceGatherer, remoteParameters: RTCIceParameters, role?: string): void;
+    start(gatherer: RTCIceGatherer, remoteParameters: RTCIceParameters, role?: RTCIceRole): void;
     stop(): void;
     addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
@@ -9099,7 +9105,7 @@ declare var RTCIceTransport: {
 }
 
 interface RTCIceTransportStateChangedEvent extends Event {
-    readonly state: string;
+    readonly state: RTCIceTransportState;
 }
 
 declare var RTCIceTransportStateChangedEvent: {
@@ -9119,8 +9125,8 @@ interface RTCPeerConnectionEventMap {
 
 interface RTCPeerConnection extends EventTarget {
     readonly canTrickleIceCandidates: boolean | null;
-    readonly iceConnectionState: string;
-    readonly iceGatheringState: string;
+    readonly iceConnectionState: RTCIceConnectionState;
+    readonly iceGatheringState: RTCIceGatheringState;
     readonly localDescription: RTCSessionDescription | null;
     onaddstream: (this: RTCPeerConnection, ev: MediaStreamEvent) => any;
     onicecandidate: (this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any;
@@ -9130,7 +9136,7 @@ interface RTCPeerConnection extends EventTarget {
     onremovestream: (this: RTCPeerConnection, ev: MediaStreamEvent) => any;
     onsignalingstatechange: (this: RTCPeerConnection, ev: Event) => any;
     readonly remoteDescription: RTCSessionDescription | null;
-    readonly signalingState: string;
+    readonly signalingState: RTCSignalingState;
     addIceCandidate(candidate: RTCIceCandidate, successCallback?: VoidFunction, failureCallback?: RTCPeerConnectionErrorCallback): Promise<void>;
     addStream(stream: MediaStream): void;
     close(): void;
@@ -9213,7 +9219,7 @@ declare var RTCRtpSender: {
 
 interface RTCSessionDescription {
     sdp: string | null;
-    type: string | null;
+    type: RTCSdpType | null;
     toJSON(): any;
 }
 
@@ -9272,7 +9278,7 @@ interface Range {
     createContextualFragment(fragment: string): DocumentFragment;
     deleteContents(): void;
     detach(): void;
-    expand(Unit: string): boolean;
+    expand(Unit: ExpandGranularity): boolean;
     extractContents(): DocumentFragment;
     getBoundingClientRect(): ClientRect;
     getClientRects(): ClientRectList;
@@ -9325,18 +9331,18 @@ declare var ReadableStreamReader: {
 }
 
 interface Request extends Object, Body {
-    readonly cache: string;
-    readonly credentials: string;
-    readonly destination: string;
+    readonly cache: RequestCache;
+    readonly credentials: RequestCredentials;
+    readonly destination: RequestDestination;
     readonly headers: Headers;
     readonly integrity: string;
     readonly keepalive: boolean;
     readonly method: string;
-    readonly mode: string;
-    readonly redirect: string;
+    readonly mode: RequestMode;
+    readonly redirect: RequestRedirect;
     readonly referrer: string;
-    readonly referrerPolicy: string;
-    readonly type: string;
+    readonly referrerPolicy: ReferrerPolicy;
+    readonly type: RequestType;
     readonly url: string;
     clone(): Request;
 }
@@ -9352,7 +9358,7 @@ interface Response extends Object, Body {
     readonly ok: boolean;
     readonly status: number;
     readonly statusText: string;
-    readonly type: string;
+    readonly type: ResponseType;
     readonly url: string;
     clone(): Response;
 }
@@ -11152,7 +11158,7 @@ declare var SVGZoomEvent: {
 
 interface ScopedCredential {
     readonly id: ArrayBuffer;
-    readonly type: string;
+    readonly type: ScopedCredentialType;
 }
 
 declare var ScopedCredential: {
@@ -11269,7 +11275,7 @@ interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
 interface ServiceWorker extends EventTarget, AbstractWorker {
     onstatechange: (this: ServiceWorker, ev: Event) => any;
     readonly scriptURL: USVString;
-    readonly state: string;
+    readonly state: ServiceWorkerState;
     postMessage(message: any, transfer?: any[]): void;
     addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
@@ -11345,7 +11351,7 @@ interface SourceBuffer extends EventTarget {
     appendWindowStart: number;
     readonly audioTracks: AudioTrackList;
     readonly buffered: TimeRanges;
-    mode: string;
+    mode: AppendMode;
     timestampOffset: number;
     readonly updating: boolean;
     readonly videoTracks: VideoTrackList;
@@ -11581,7 +11587,7 @@ interface Text extends CharacterData {
 
 declare var Text: {
     prototype: Text;
-    new(): Text;
+    new(data?: string): Text;
 }
 
 interface TextEvent extends UIEvent {
@@ -11764,7 +11770,7 @@ interface TouchEvent extends UIEvent {
 
 declare var TouchEvent: {
     prototype: TouchEvent;
-    new(): TouchEvent;
+    new(type: string, touchEventInit?: TouchEventInit): TouchEvent;
 }
 
 interface TouchList {
@@ -11970,7 +11976,7 @@ declare var WEBGL_depth_texture: {
 
 interface WaveShaperNode extends AudioNode {
     curve: Float32Array | null;
-    oversample: string;
+    oversample: OverSampleType;
 }
 
 declare var WaveShaperNode: {
@@ -13231,6 +13237,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     readonly top: Window;
     readonly window: Window;
     URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
     Blob: typeof Blob;
     customElements: CustomElementRegistry;
     alert(message?: any): void;
@@ -13239,7 +13246,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     captureEvents(): void;
     close(): void;
     confirm(message?: string): boolean;
-    departFocus(navigationReason: string, origin: FocusNavigationOrigin): void;
+    departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
     focus(): void;
     getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
     getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList;
@@ -13314,7 +13321,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
     readonly readyState: number;
     readonly response: any;
     readonly responseText: string;
-    responseType: string;
+    responseType: XMLHttpRequestResponseType;
     readonly responseURL: string;
     readonly responseXML: Document | null;
     readonly status: number;
@@ -14171,6 +14178,21 @@ interface PromiseRejectionEventInit extends EventInit {
     reason?: any;
 }
 
+interface EventListenerOptions {
+    capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+    passive?: boolean;
+    once?: boolean;
+}
+
+interface TouchEventInit extends EventModifierInit {
+    touches?: Touch[];
+    targetTouches?: Touch[];
+    changedTouches?: Touch[];
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -14228,10 +14250,10 @@ interface NavigatorUserMediaErrorCallback {
     (error: MediaStreamError): void;
 }
 interface ForEachCallback {
-    (keyId: any, status: string): void;
+    (keyId: any, status: MediaKeyStatus): void;
 }
 interface NotificationPermissionCallback {
-    (permission: string): void;
+    (permission: NotificationPermission): void;
 }
 interface IntersectionObserverCallback {
     (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
@@ -14838,7 +14860,7 @@ declare function cancelAnimationFrame(handle: number): void;
 declare function captureEvents(): void;
 declare function close(): void;
 declare function confirm(message?: string): boolean;
-declare function departFocus(navigationReason: string, origin: FocusNavigationOrigin): void;
+declare function departFocus(navigationReason: NavigationReason, origin: FocusNavigationOrigin): void;
 declare function focus(): void;
 declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
 declare function getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList;
@@ -14870,7 +14892,7 @@ declare function scrollTo(options?: ScrollToOptions): void;
 declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function dispatchEvent(evt: Event): boolean;
-declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 declare function clearInterval(handle: number): void;
 declare function clearTimeout(handle: number): void;
 declare function setInterval(handler: (...args: any[]) => void, timeout: number): number;
@@ -14939,4 +14961,76 @@ type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;
-type ScrollRestoration = "auto" | "manual";
\ No newline at end of file
+type ScrollRestoration = "auto" | "manual";
+type FormDataEntryValue = string | File;
+type AppendMode = "segments" | "sequence";
+type AudioContextState = "suspended" | "running" | "closed";
+type BiquadFilterType = "lowpass" | "highpass" | "bandpass" | "lowshelf" | "highshelf" | "peaking" | "notch" | "allpass";
+type CanvasFillRule = "nonzero" | "evenodd";
+type ChannelCountMode = "max" | "clamped-max" | "explicit";
+type ChannelInterpretation = "speakers" | "discrete";
+type DistanceModelType = "linear" | "inverse" | "exponential";
+type ExpandGranularity = "character" | "word" | "sentence" | "textedit";
+type GamepadInputEmulationType = "mouse" | "keyboard" | "gamepad";
+type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
+type IDBRequestReadyState = "pending" | "done";
+type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
+type ListeningState = "inactive" | "active" | "disambiguation";
+type MSCredentialType = "FIDO_2_0";
+type MSIceAddrType = "os" | "stun" | "turn" | "peer-derived";
+type MSIceType = "failed" | "direct" | "relay";
+type MSStatsType = "description" | "localclientevent" | "inbound-network" | "outbound-network" | "inbound-payload" | "outbound-payload" | "transportdiagnostics";
+type MSTransportType = "Embedded" | "USB" | "NFC" | "BT";
+type MSWebViewPermissionState = "unknown" | "defer" | "allow" | "deny";
+type MSWebViewPermissionType = "geolocation" | "unlimitedIndexedDBQuota" | "media" | "pointerlock" | "webnotifications";
+type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
+type MediaKeyMessageType = "license-request" | "license-renewal" | "license-release" | "individualization-request";
+type MediaKeySessionType = "temporary" | "persistent-license" | "persistent-release-message";
+type MediaKeyStatus = "usable" | "expired" | "output-downscaled" | "output-not-allowed" | "status-pending" | "internal-error";
+type MediaKeysRequirement = "required" | "optional" | "not-allowed";
+type MediaStreamTrackState = "live" | "ended";
+type NavigationReason = "up" | "down" | "left" | "right";
+type NavigationType = "navigate" | "reload" | "back_forward" | "prerender";
+type NotificationDirection = "auto" | "ltr" | "rtl";
+type NotificationPermission = "default" | "denied" | "granted";
+type OscillatorType = "sine" | "square" | "sawtooth" | "triangle" | "custom";
+type OverSampleType = "none" | "2x" | "4x";
+type PanningModelType = "equalpower";
+type PaymentComplete = "success" | "fail" | "";
+type PaymentShippingType = "shipping" | "delivery" | "pickup";
+type PushEncryptionKeyName = "p256dh" | "auth";
+type PushPermissionState = "granted" | "denied" | "prompt";
+type RTCBundlePolicy = "balanced" | "max-compat" | "max-bundle";
+type RTCDegradationPreference = "maintain-framerate" | "maintain-resolution" | "balanced";
+type RTCDtlsRole = "auto" | "client" | "server";
+type RTCDtlsTransportState = "new" | "connecting" | "connected" | "closed";
+type RTCIceCandidateType = "host" | "srflx" | "prflx" | "relay";
+type RTCIceComponent = "RTP" | "RTCP";
+type RTCIceConnectionState = "new" | "checking" | "connected" | "completed" | "failed" | "disconnected" | "closed";
+type RTCIceGatherPolicy = "all" | "nohost" | "relay";
+type RTCIceGathererState = "new" | "gathering" | "complete";
+type RTCIceGatheringState = "new" | "gathering" | "complete";
+type RTCIceProtocol = "udp" | "tcp";
+type RTCIceRole = "controlling" | "controlled";
+type RTCIceTcpCandidateType = "active" | "passive" | "so";
+type RTCIceTransportPolicy = "none" | "relay" | "all";
+type RTCIceTransportState = "new" | "checking" | "connected" | "completed" | "disconnected" | "closed";
+type RTCSdpType = "offer" | "pranswer" | "answer";
+type RTCSignalingState = "stable" | "have-local-offer" | "have-remote-offer" | "have-local-pranswer" | "have-remote-pranswer" | "closed";
+type RTCStatsIceCandidatePairState = "frozen" | "waiting" | "inprogress" | "failed" | "succeeded" | "cancelled";
+type RTCStatsIceCandidateType = "host" | "serverreflexive" | "peerreflexive" | "relayed";
+type RTCStatsType = "inboundrtp" | "outboundrtp" | "session" | "datachannel" | "track" | "transport" | "candidatepair" | "localcandidate" | "remotecandidate";
+type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url";
+type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache";
+type RequestCredentials = "omit" | "same-origin" | "include";
+type RequestDestination = "" | "document" | "sharedworker" | "subresource" | "unknown" | "worker";
+type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
+type RequestRedirect = "follow" | "error" | "manual";
+type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video";
+type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
+type ScopedCredentialType = "ScopedCred";
+type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant";
+type Transport = "usb" | "nfc" | "ble";
+type VideoFacingModeEnum = "user" | "environment" | "left" | "right";
+type VisibilityState = "hidden" | "visible" | "prerender" | "unloaded";
+type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
\ No newline at end of file
diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts
index b2255dab881..038ed1ed58c 100644
--- a/src/lib/es2015.collection.d.ts
+++ b/src/lib/es2015.collection.d.ts
@@ -30,9 +30,9 @@ interface WeakMap<K extends object, V> {
 }
 
 interface WeakMapConstructor {
-    new (): WeakMap<any, any>;
+    new (): WeakMap<object, any>;
     new <K extends object, V>(entries?: [K, V][]): WeakMap<K, V>;
-    readonly prototype: WeakMap<any, any>;
+    readonly prototype: WeakMap<object, any>;
 }
 declare var WeakMap: WeakMapConstructor;
 
@@ -58,15 +58,15 @@ interface ReadonlySet<T> {
     readonly size: number;
 }
 
-interface WeakSet<T> {
+interface WeakSet<T extends object> {
     add(value: T): this;
     delete(value: T): boolean;
     has(value: T): boolean;
 }
 
 interface WeakSetConstructor {
-    new (): WeakSet<any>;
-    new <T>(values?: T[]): WeakSet<T>;
-    readonly prototype: WeakSet<any>;
+    new (): WeakSet<object>;
+    new <T extends object>(values?: T[]): WeakSet<T>;
+    readonly prototype: WeakSet<object>;
 }
 declare var WeakSet: WeakSetConstructor;
diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts
index 341fd80872c..9c84fc259c7 100644
--- a/src/lib/es2015.core.d.ts
+++ b/src/lib/es2015.core.d.ts
@@ -10,8 +10,8 @@ interface Array<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    find(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean): T | undefined;
-    find(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): T | undefined;
+    find(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean): T | undefined;
+    find(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): T | undefined;
     find<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): T | undefined;
 
     /**
@@ -23,8 +23,8 @@ interface Array<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    findIndex(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean): number;
+    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): number;
 
     /**
@@ -56,8 +56,8 @@ interface ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): Array<U>;
-    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array<U>;
+    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): Array<U>;
+    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array<U>;
     from<Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array<U>;
 
 
@@ -311,7 +311,7 @@ interface ObjectConstructor {
      * @param target The target object to copy to.
      * @param sources One or more source objects from which to copy properties
      */
-    assign(target: any, ...sources: any[]): any;
+    assign(target: object, ...sources: any[]): any;
 
     /**
      * Returns an array of all symbol properties found directly on object o.
@@ -363,8 +363,8 @@ interface ReadonlyArray<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined;
-    find(predicate: (this: undefined, value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg: undefined): T | undefined;
+    find(predicate: (this: void, value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined;
+    find(predicate: (this: void, value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg: undefined): T | undefined;
     find<Z>(predicate: (this: Z, value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg: Z): T | undefined;
 
     /**
@@ -376,8 +376,8 @@ interface ReadonlyArray<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    findIndex(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean): number;
+    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): number;
 }
 
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 03c583dc155..d242d14b663 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -54,8 +54,8 @@ interface ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from<T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): Array<U>;
-    from<T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): Array<U>;
+    from<T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): Array<U>;
+    from<T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array<U>;
     from<Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array<U>;
 
     /**
@@ -118,10 +118,10 @@ interface SetConstructor {
     new <T>(iterable: Iterable<T>): Set<T>;
 }
 
-interface WeakSet<T> { }
+interface WeakSet<T extends object> { }
 
 interface WeakSetConstructor {
-    new <T>(iterable: Iterable<T>): WeakSet<T>;
+    new <T extends object>(iterable: Iterable<T>): WeakSet<T>;
 }
 
 interface Promise<T> { }
@@ -145,7 +145,7 @@ interface PromiseConstructor {
 }
 
 declare namespace Reflect {
-    function enumerate(target: any): IterableIterator<any>;
+    function enumerate(target: object): IterableIterator<any>;
 }
 
 interface String {
@@ -182,8 +182,8 @@ interface Int8ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array;
 
     from(arrayLike: Iterable<number>): Int8Array;
@@ -218,8 +218,8 @@ interface Uint8ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array;
 
     from(arrayLike: Iterable<number>): Uint8Array;
@@ -257,8 +257,8 @@ interface Uint8ClampedArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray;
 
     from(arrayLike: Iterable<number>): Uint8ClampedArray;
@@ -295,8 +295,8 @@ interface Int16ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array;
 
     from(arrayLike: Iterable<number>): Int16Array;
@@ -331,8 +331,8 @@ interface Uint16ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array;
 
     from(arrayLike: Iterable<number>): Uint16Array;
@@ -367,8 +367,8 @@ interface Int32ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array;
 
     from(arrayLike: Iterable<number>): Int32Array;
@@ -403,8 +403,8 @@ interface Uint32ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array;
 
     from(arrayLike: Iterable<number>): Uint32Array;
@@ -439,8 +439,8 @@ interface Float32ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array;
 
     from(arrayLike: Iterable<number>): Float32Array;
@@ -475,8 +475,8 @@ interface Float64ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array;
-    from(arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array;
+    from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array;
 
     from(arrayLike: Iterable<number>): Float64Array;
diff --git a/src/lib/es2015.proxy.d.ts b/src/lib/es2015.proxy.d.ts
index 89f9ebf55c0..c1b7805bbcf 100644
--- a/src/lib/es2015.proxy.d.ts
+++ b/src/lib/es2015.proxy.d.ts
@@ -1,4 +1,4 @@
-interface ProxyHandler<T> {
+interface ProxyHandler<T extends object> {
     getPrototypeOf? (target: T): object | null;
     setPrototypeOf? (target: T, v: any): boolean;
     isExtensible? (target: T): boolean;
@@ -16,7 +16,7 @@ interface ProxyHandler<T> {
 }
 
 interface ProxyConstructor {
-    revocable<T>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
-    new <T>(target: T, handler: ProxyHandler<T>): T;
+    revocable<T extends object>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
+    new <T extends object>(target: T, handler: ProxyHandler<T>): T;
 }
 declare var Proxy: ProxyConstructor;
diff --git a/src/lib/es2015.reflect.d.ts b/src/lib/es2015.reflect.d.ts
index 2dc92c3bddb..83755e4c791 100644
--- a/src/lib/es2015.reflect.d.ts
+++ b/src/lib/es2015.reflect.d.ts
@@ -1,15 +1,15 @@
 declare namespace Reflect {
     function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
     function construct(target: Function, argumentsList: ArrayLike<any>, newTarget?: any): any;
-    function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
-    function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
-    function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
-    function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
-    function getPrototypeOf(target: any): any;
-    function has(target: any, propertyKey: PropertyKey): boolean;
-    function isExtensible(target: any): boolean;
-    function ownKeys(target: any): Array<PropertyKey>;
-    function preventExtensions(target: any): boolean;
-    function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
-    function setPrototypeOf(target: any, proto: any): boolean;
-}
\ No newline at end of file
+    function defineProperty(target: object, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+    function deleteProperty(target: object, propertyKey: PropertyKey): boolean;
+    function get(target: object, propertyKey: PropertyKey, receiver?: any): any;
+    function getOwnPropertyDescriptor(target: object, propertyKey: PropertyKey): PropertyDescriptor;
+    function getPrototypeOf(target: object): object;
+    function has(target: object, propertyKey: PropertyKey): boolean;
+    function isExtensible(target: object): boolean;
+    function ownKeys(target: object): Array<PropertyKey>;
+    function preventExtensions(target: object): boolean;
+    function set(target: object, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+    function setPrototypeOf(target: object, proto: any): boolean;
+}
diff --git a/src/lib/es2015.symbol.wellknown.d.ts b/src/lib/es2015.symbol.wellknown.d.ts
index 578cf0acbc2..3d030f37d49 100644
--- a/src/lib/es2015.symbol.wellknown.d.ts
+++ b/src/lib/es2015.symbol.wellknown.d.ts
@@ -118,7 +118,7 @@ interface Set<T> {
     readonly [Symbol.toStringTag]: "Set";
 }
 
-interface WeakSet<T> {
+interface WeakSet<T extends object> {
     readonly [Symbol.toStringTag]: "WeakSet";
 }
 
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index b92d335457a..69460f40c16 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1017,48 +1017,48 @@ interface ReadonlyArray<T> {
       * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
+    every(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: Z): boolean;
     /**
       * Determines whether the specified callback function returns true for any element of an array.
       * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
+    some(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg: Z): boolean;
     /**
       * Performs the specified action for each element in an array.
       * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => void): void;
-    forEach(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => void): void;
+    forEach(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => void, thisArg: Z): void;
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => U): U[];
-    map<U>(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => U, thisArg: undefined): U[];
+    map<U>(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => U): U[];
+    map<U>(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => U, thisArg: undefined): U[];
     map<Z, U>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => U, thisArg: Z): U[];
     /**
      * Returns the elements of an array that meet the condition specified in a callback function.
      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
-    filter<S extends T>(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => value is S): S[];
-    filter<S extends T>(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => value is S, thisArg: undefined): S[];
+    filter<S extends T>(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => value is S): S[];
+    filter<S extends T>(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => value is S, thisArg: undefined): S[];
     filter<Z, S extends T>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => value is S, thisArg: Z): S[];
     /**
       * Returns the elements of an array that meet the condition specified in a callback function.
       * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => any): T[];
-    filter(callbackfn: (this: undefined, value: T, index: number, array: ReadonlyArray<T>) => any, thisArg: undefined): T[];
+    filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => any): T[];
+    filter(callbackfn: (this: void, value: T, index: number, array: ReadonlyArray<T>) => any, thisArg: undefined): T[];
     filter<Z>(callbackfn: (this: Z, value: T, index: number, array: ReadonlyArray<T>) => any, thisArg: Z): T[];
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -1176,72 +1176,72 @@ interface Array<T> {
       * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean): boolean;
+    every(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: T, index: number, array: T[]) => boolean, thisArg: Z): boolean;
     /**
       * Determines whether the specified callback function returns true for any element of an array.
       * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean): boolean;
+    some(callbackfn: (this: void, value: T, index: number, array: T[]) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: T, index: number, array: T[]) => boolean, thisArg: Z): boolean;
     /**
       * Performs the specified action for each element in an array.
       * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: T, index: number, array: T[]) => void): void;
-    forEach(callbackfn: (this: undefined, value: T, index: number, array: T[]) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: T, index: number, array: T[]) => void): void;
+    forEach(callbackfn: (this: void, value: T, index: number, array: T[]) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: T, index: number, array: T[]) => void, thisArg: Z): void;
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U];
-    map<U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U];
+    map<U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U];
+    map<U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U];
     map<Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U];
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U];
-    map<U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U];
+    map<U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U];
+    map<U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U];
     map<Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U];
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U];
-    map<U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U];
+    map<U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U];
+    map<U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U];
     map<Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U];
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U];
-    map<U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U];
+    map<U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U];
+    map<U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U];
     map<Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U];
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    map<U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[];
-    map<U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[];
+    map<U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[];
+    map<U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[];
     map<Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[];
     /**
       * Returns the elements of an array that meet the condition specified in a callback function.
       * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: T, index: number, array: T[]) => any): T[];
-    filter(callbackfn: (this: undefined, value: T, index: number, array: T[]) => any, thisArg: undefined): T[];
+    filter(callbackfn: (this: void, value: T, index: number, array: T[]) => any): T[];
+    filter(callbackfn: (this: void, value: T, index: number, array: T[]) => any, thisArg: undefined): T[];
     filter<Z>(callbackfn: (this: Z, value: T, index: number, array: T[]) => any, thisArg: Z): T[];
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -1587,8 +1587,8 @@ interface Int8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -1608,8 +1608,8 @@ interface Int8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => any): Int8Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => any, thisArg: undefined): Int8Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any): Int8Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any, thisArg: undefined): Int8Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => any, thisArg: Z): Int8Array;
 
     /**
@@ -1621,8 +1621,8 @@ interface Int8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -1634,8 +1634,8 @@ interface Int8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -1645,8 +1645,8 @@ interface Int8Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => void, thisArg: Z): void;
 
     /**
@@ -1685,8 +1685,8 @@ interface Int8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => number): Int8Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => number, thisArg: undefined): Int8Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number): Int8Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number, thisArg: undefined): Int8Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => number, thisArg: Z): Int8Array;
 
     /**
@@ -1771,8 +1771,8 @@ interface Int8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -1825,8 +1825,8 @@ interface Int8ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array;
 
     from(arrayLike: ArrayLike<number>): Int8Array;
@@ -1878,8 +1878,8 @@ interface Uint8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -1899,8 +1899,8 @@ interface Uint8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => any): Uint8Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => any, thisArg: undefined): Uint8Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any): Uint8Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any, thisArg: undefined): Uint8Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => any, thisArg: Z): Uint8Array;
 
     /**
@@ -1912,8 +1912,8 @@ interface Uint8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -1925,8 +1925,8 @@ interface Uint8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -1936,8 +1936,8 @@ interface Uint8Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => void, thisArg: Z): void;
 
     /**
@@ -1976,8 +1976,8 @@ interface Uint8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => number): Uint8Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => number, thisArg: undefined): Uint8Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number): Uint8Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number, thisArg: undefined): Uint8Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => number, thisArg: Z): Uint8Array;
 
     /**
@@ -2062,8 +2062,8 @@ interface Uint8Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2117,8 +2117,8 @@ interface Uint8ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array;
 
     from(arrayLike: ArrayLike<number>): Uint8Array;
@@ -2170,8 +2170,8 @@ interface Uint8ClampedArray {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2191,8 +2191,8 @@ interface Uint8ClampedArray {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => any): Uint8ClampedArray;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: undefined): Uint8ClampedArray;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any): Uint8ClampedArray;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: undefined): Uint8ClampedArray;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: Z): Uint8ClampedArray;
 
     /**
@@ -2204,8 +2204,8 @@ interface Uint8ClampedArray {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -2217,8 +2217,8 @@ interface Uint8ClampedArray {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -2228,8 +2228,8 @@ interface Uint8ClampedArray {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: Z): void;
 
     /**
@@ -2268,8 +2268,8 @@ interface Uint8ClampedArray {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => number): Uint8ClampedArray;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: undefined): Uint8ClampedArray;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number): Uint8ClampedArray;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: undefined): Uint8ClampedArray;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: Z): Uint8ClampedArray;
 
     /**
@@ -2354,8 +2354,8 @@ interface Uint8ClampedArray {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2409,8 +2409,8 @@ interface Uint8ClampedArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray;
 
     from(arrayLike: ArrayLike<number>): Uint8ClampedArray;
@@ -2461,8 +2461,8 @@ interface Int16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2482,8 +2482,8 @@ interface Int16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => any): Int16Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => any, thisArg: undefined): Int16Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any): Int16Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any, thisArg: undefined): Int16Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => any, thisArg: Z): Int16Array;
 
     /**
@@ -2495,8 +2495,8 @@ interface Int16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -2508,8 +2508,8 @@ interface Int16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -2519,8 +2519,8 @@ interface Int16Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => void, thisArg: Z): void;
 
     /**
@@ -2559,8 +2559,8 @@ interface Int16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => number): Int16Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => number, thisArg: undefined): Int16Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number): Int16Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number, thisArg: undefined): Int16Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => number, thisArg: Z): Int16Array;
 
     /**
@@ -2645,8 +2645,8 @@ interface Int16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2700,8 +2700,8 @@ interface Int16ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array;
 
     from(arrayLike: ArrayLike<number>): Int16Array;
@@ -2753,8 +2753,8 @@ interface Uint16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2774,8 +2774,8 @@ interface Uint16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => any): Uint16Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => any, thisArg: undefined): Uint16Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any): Uint16Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any, thisArg: undefined): Uint16Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => any, thisArg: Z): Uint16Array;
 
     /**
@@ -2787,8 +2787,8 @@ interface Uint16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -2800,8 +2800,8 @@ interface Uint16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -2811,8 +2811,8 @@ interface Uint16Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => void, thisArg: Z): void;
 
     /**
@@ -2851,8 +2851,8 @@ interface Uint16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => number): Uint16Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => number, thisArg: undefined): Uint16Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number): Uint16Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number, thisArg: undefined): Uint16Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => number, thisArg: Z): Uint16Array;
 
     /**
@@ -2937,8 +2937,8 @@ interface Uint16Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -2992,8 +2992,8 @@ interface Uint16ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array;
 
     from(arrayLike: ArrayLike<number>): Uint16Array;
@@ -3044,8 +3044,8 @@ interface Int32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3065,8 +3065,8 @@ interface Int32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => any): Int32Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => any, thisArg: undefined): Int32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any): Int32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any, thisArg: undefined): Int32Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => any, thisArg: Z): Int32Array;
 
     /**
@@ -3078,8 +3078,8 @@ interface Int32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -3091,8 +3091,8 @@ interface Int32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -3102,8 +3102,8 @@ interface Int32Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => void, thisArg: Z): void;
 
     /**
@@ -3142,8 +3142,8 @@ interface Int32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => number): Int32Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => number, thisArg: undefined): Int32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number): Int32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number, thisArg: undefined): Int32Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => number, thisArg: Z): Int32Array;
 
     /**
@@ -3228,8 +3228,8 @@ interface Int32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3283,8 +3283,8 @@ interface Int32ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array;
 
     from(arrayLike: ArrayLike<number>): Int32Array;
@@ -3335,8 +3335,8 @@ interface Uint32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3356,8 +3356,8 @@ interface Uint32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => any): Uint32Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => any, thisArg: undefined): Uint32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any): Uint32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any, thisArg: undefined): Uint32Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => any, thisArg: Z): Uint32Array;
 
     /**
@@ -3369,8 +3369,8 @@ interface Uint32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -3382,8 +3382,8 @@ interface Uint32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -3393,8 +3393,8 @@ interface Uint32Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => void, thisArg: Z): void;
 
     /**
@@ -3433,8 +3433,8 @@ interface Uint32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => number): Uint32Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => number, thisArg: undefined): Uint32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number): Uint32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number, thisArg: undefined): Uint32Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => number, thisArg: Z): Uint32Array;
 
     /**
@@ -3519,8 +3519,8 @@ interface Uint32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3574,8 +3574,8 @@ interface Uint32ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array;
 
     from(arrayLike: ArrayLike<number>): Uint32Array;
@@ -3626,8 +3626,8 @@ interface Float32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3647,8 +3647,8 @@ interface Float32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => any): Float32Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => any, thisArg: undefined): Float32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any): Float32Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any, thisArg: undefined): Float32Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => any, thisArg: Z): Float32Array;
 
     /**
@@ -3660,8 +3660,8 @@ interface Float32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -3673,8 +3673,8 @@ interface Float32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -3684,8 +3684,8 @@ interface Float32Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => void, thisArg: Z): void;
 
     /**
@@ -3724,8 +3724,8 @@ interface Float32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => number): Float32Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => number, thisArg: undefined): Float32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number): Float32Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number, thisArg: undefined): Float32Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => number, thisArg: Z): Float32Array;
 
     /**
@@ -3810,8 +3810,8 @@ interface Float32Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3865,8 +3865,8 @@ interface Float32ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array;
 
     from(arrayLike: ArrayLike<number>): Float32Array;
@@ -3918,8 +3918,8 @@ interface Float64Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    every(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean): boolean;
-    every(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
     every<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -3939,8 +3939,8 @@ interface Float64Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => any): Float64Array;
-    filter(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => any, thisArg: undefined): Float64Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any): Float64Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any, thisArg: undefined): Float64Array;
     filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => any, thisArg: Z): Float64Array;
 
     /**
@@ -3952,8 +3952,8 @@ interface Float64Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
     find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
 
     /**
@@ -3965,8 +3965,8 @@ interface Float64Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: undefined, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
     findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
 
     /**
@@ -3976,8 +3976,8 @@ interface Float64Array {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => void): void;
-    forEach(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => void, thisArg: undefined): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void, thisArg: undefined): void;
     forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => void, thisArg: Z): void;
 
     /**
@@ -4016,8 +4016,8 @@ interface Float64Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    map(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => number): Float64Array;
-    map(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => number, thisArg: undefined): Float64Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number): Float64Array;
+    map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number, thisArg: undefined): Float64Array;
     map<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => number, thisArg: Z): Float64Array;
 
     /**
@@ -4102,8 +4102,8 @@ interface Float64Array {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function.
       * If thisArg is omitted, undefined is used as the this value.
       */
-    some(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean): boolean;
-    some(callbackfn: (this: undefined, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
     some<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean;
 
     /**
@@ -4157,8 +4157,8 @@ interface Float64ArrayConstructor {
       * @param mapfn A mapping function to call on every element of the array.
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array;
 
     from(arrayLike: ArrayLike<number>): Float64Array;
diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts
index 326a3a9546e..62d6d2d67a7 100644
--- a/src/lib/webworker.generated.d.ts
+++ b/src/lib/webworker.generated.d.ts
@@ -54,13 +54,17 @@ interface MessageEventInit extends EventInit {
 }
 
 interface NotificationOptions {
-    dir?: string;
+    dir?: NotificationDirection;
     lang?: string;
     body?: string;
     tag?: string;
     icon?: string;
 }
 
+interface ObjectURLOptions {
+    oneTimeOnly?: boolean;
+}
+
 interface PushSubscriptionOptionsInit {
     userVisibleOnly?: boolean;
     applicationServerKey?: any;
@@ -71,11 +75,11 @@ interface RequestInit {
     headers?: any;
     body?: any;
     referrer?: string;
-    referrerPolicy?: string;
-    mode?: string;
-    credentials?: string;
-    cache?: string;
-    redirect?: string;
+    referrerPolicy?: ReferrerPolicy;
+    mode?: RequestMode;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
     integrity?: string;
     keepalive?: boolean;
     window?: any;
@@ -89,7 +93,7 @@ interface ResponseInit {
 
 interface ClientQueryOptions {
     includeUncontrolled?: boolean;
-    type?: string;
+    type?: ClientType;
 }
 
 interface ExtendableEventInit extends EventInit {
@@ -399,9 +403,9 @@ declare var Event: {
 }
 
 interface EventTarget {
-    addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    addEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     dispatchEvent(evt: Event): boolean;
-    removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+    removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
 declare var EventTarget: {
@@ -461,7 +465,7 @@ declare var Headers: {
 }
 
 interface IDBCursor {
-    readonly direction: string;
+    readonly direction: IDBCursorDirection;
     key: IDBKeyRange | IDBValidKey;
     readonly primaryKey: any;
     source: IDBObjectStore | IDBIndex;
@@ -613,7 +617,7 @@ interface IDBRequest extends EventTarget {
     readonly error: DOMError;
     onerror: (this: IDBRequest, ev: Event) => any;
     onsuccess: (this: IDBRequest, ev: Event) => any;
-    readonly readyState: string;
+    readonly readyState: IDBRequestReadyState;
     readonly result: any;
     source: IDBObjectStore | IDBIndex | IDBCursor;
     readonly transaction: IDBTransaction;
@@ -635,7 +639,7 @@ interface IDBTransactionEventMap {
 interface IDBTransaction extends EventTarget {
     readonly db: IDBDatabase;
     readonly error: DOMError;
-    readonly mode: string;
+    readonly mode: IDBTransactionMode;
     onabort: (this: IDBTransaction, ev: Event) => any;
     oncomplete: (this: IDBTransaction, ev: Event) => any;
     onerror: (this: IDBTransaction, ev: Event) => any;
@@ -728,14 +732,14 @@ interface NotificationEventMap {
 
 interface Notification extends EventTarget {
     readonly body: string;
-    readonly dir: string;
+    readonly dir: NotificationDirection;
     readonly icon: string;
     readonly lang: string;
     onclick: (this: Notification, ev: Event) => any;
     onclose: (this: Notification, ev: Event) => any;
     onerror: (this: Notification, ev: Event) => any;
     onshow: (this: Notification, ev: Event) => any;
-    readonly permission: string;
+    readonly permission: NotificationPermission;
     readonly tag: string;
     readonly title: string;
     close(): void;
@@ -746,7 +750,7 @@ interface Notification extends EventTarget {
 declare var Notification: {
     prototype: Notification;
     new(title: string, options?: NotificationOptions): Notification;
-    requestPermission(callback?: NotificationPermissionCallback): Promise<string>;
+    requestPermission(callback?: NotificationPermissionCallback): Promise<NotificationPermission>;
 }
 
 interface Performance {
@@ -863,7 +867,7 @@ declare var ProgressEvent: {
 
 interface PushManager {
     getSubscription(): Promise<PushSubscription>;
-    permissionState(options?: PushSubscriptionOptionsInit): Promise<string>;
+    permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
     subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
 }
 
@@ -875,7 +879,7 @@ declare var PushManager: {
 interface PushSubscription {
     readonly endpoint: USVString;
     readonly options: PushSubscriptionOptions;
-    getKey(name: string): ArrayBuffer | null;
+    getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
     toJSON(): any;
     unsubscribe(): Promise<boolean>;
 }
@@ -918,18 +922,18 @@ declare var ReadableStreamReader: {
 }
 
 interface Request extends Object, Body {
-    readonly cache: string;
-    readonly credentials: string;
-    readonly destination: string;
+    readonly cache: RequestCache;
+    readonly credentials: RequestCredentials;
+    readonly destination: RequestDestination;
     readonly headers: Headers;
     readonly integrity: string;
     readonly keepalive: boolean;
     readonly method: string;
-    readonly mode: string;
-    readonly redirect: string;
+    readonly mode: RequestMode;
+    readonly redirect: RequestRedirect;
     readonly referrer: string;
-    readonly referrerPolicy: string;
-    readonly type: string;
+    readonly referrerPolicy: ReferrerPolicy;
+    readonly type: RequestType;
     readonly url: string;
     clone(): Request;
 }
@@ -945,7 +949,7 @@ interface Response extends Object, Body {
     readonly ok: boolean;
     readonly status: number;
     readonly statusText: string;
-    readonly type: string;
+    readonly type: ResponseType;
     readonly url: string;
     clone(): Response;
 }
@@ -962,7 +966,7 @@ interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
 interface ServiceWorker extends EventTarget, AbstractWorker {
     onstatechange: (this: ServiceWorker, ev: Event) => any;
     readonly scriptURL: USVString;
-    readonly state: string;
+    readonly state: ServiceWorkerState;
     postMessage(message: any, transfer?: any[]): void;
     addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
@@ -1008,6 +1012,29 @@ declare var SyncManager: {
     new(): SyncManager;
 }
 
+interface URL {
+    hash: string;
+    host: string;
+    hostname: string;
+    href: string;
+    readonly origin: string;
+    password: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    username: string;
+    readonly searchParams: URLSearchParams;
+    toString(): string;
+}
+
+declare var URL: {
+    prototype: URL;
+    new(url: string, base?: string): URL;
+    createObjectURL(object: any, options?: ObjectURLOptions): string;
+    revokeObjectURL(url: string): void;
+}
+
 interface WebSocketEventMap {
     "close": CloseEvent;
     "error": Event;
@@ -1071,7 +1098,7 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
     readonly readyState: number;
     readonly response: any;
     readonly responseText: string;
-    responseType: string;
+    responseType: XMLHttpRequestResponseType;
     readonly responseURL: string;
     readonly responseXML: any;
     readonly status: number;
@@ -1222,7 +1249,7 @@ interface XMLHttpRequestEventTarget {
 }
 
 interface Client {
-    readonly frameType: string;
+    readonly frameType: FrameType;
     readonly id: string;
     readonly url: USVString;
     postMessage(message: any, transfer?: any[]): void;
@@ -1385,7 +1412,7 @@ declare var SyncEvent: {
 
 interface WindowClient extends Client {
     readonly focused: boolean;
-    readonly visibilityState: string;
+    readonly visibilityState: VisibilityState;
     focus(): Promise<WindowClient>;
     navigate(url: USVString): Promise<WindowClient>;
 }
@@ -1484,6 +1511,41 @@ interface ImageBitmap {
     close(): void;
 }
 
+interface URLSearchParams {
+    /**
+      * Appends a specified key/value pair as a new search parameter.
+      */
+    append(name: string, value: string): void;
+    /**
+      * Deletes the given search parameter, and its associated value, from the list of all search parameters.
+      */
+    delete(name: string): void;
+    /**
+      * Returns the first value associated to the given search parameter.
+      */
+    get(name: string): string | null;
+    /**
+      * Returns all the values association with a given search parameter.
+      */
+    getAll(name: string): string[];
+    /**
+      * Returns a Boolean indicating if such a search parameter exists.
+      */
+    has(name: string): boolean;
+    /**
+      * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
+      */
+    set(name: string, value: string): void;
+}
+
+declare var URLSearchParams: {
+    prototype: URLSearchParams;
+    /**
+      * Constructor returning a URLSearchParams object.
+      */
+    new (init?: string | URLSearchParams): URLSearchParams;
+}
+
 interface BlobPropertyBag {
     type?: string;
     endings?: string;
@@ -1678,6 +1740,15 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface EventListenerOptions {
+    capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+    passive?: boolean;
+    once?: boolean;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -1699,10 +1770,10 @@ interface FunctionStringCallback {
     (data: string): void;
 }
 interface ForEachCallback {
-    (keyId: any, status: string): void;
+    (keyId: any, status: MediaKeyStatus): void;
 }
 interface NotificationPermissionCallback {
-    (permission: string): void;
+    (permission: NotificationPermission): void;
 }
 declare var onmessage: (this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any;
 declare function close(): void;
@@ -1717,7 +1788,7 @@ declare function msWriteProfilerMark(profilerMarkName: string): void;
 declare function createImageBitmap(image: ImageBitmap | ImageData | Blob, options?: ImageBitmapOptions): Promise<ImageBitmap>;
 declare function createImageBitmap(image: ImageBitmap | ImageData | Blob, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
 declare function dispatchEvent(evt: Event): boolean;
-declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 declare var indexedDB: IDBFactory;
 declare var msIndexedDB: IDBFactory;
 declare var navigator: WorkerNavigator;
@@ -1736,7 +1807,7 @@ declare function btoa(rawString: string): string;
 declare var console: Console;
 declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
 declare function dispatchEvent(evt: Event): boolean;
-declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 declare function addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, useCapture?: boolean): void;
 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 type AlgorithmIdentifier = string | Algorithm;
@@ -1745,4 +1816,26 @@ type IDBKeyPath = string;
 type RequestInfo = Request | string;
 type USVString = string;
 type IDBValidKey = number | string | Date | IDBArrayKey;
-type BufferSource = ArrayBuffer | ArrayBufferView;
\ No newline at end of file
+type BufferSource = ArrayBuffer | ArrayBufferView;
+type FormDataEntryValue = string | File;
+type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
+type IDBRequestReadyState = "pending" | "done";
+type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
+type MediaKeyStatus = "usable" | "expired" | "output-downscaled" | "output-not-allowed" | "status-pending" | "internal-error";
+type NotificationDirection = "auto" | "ltr" | "rtl";
+type NotificationPermission = "default" | "denied" | "granted";
+type PushEncryptionKeyName = "p256dh" | "auth";
+type PushPermissionState = "granted" | "denied" | "prompt";
+type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url";
+type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache";
+type RequestCredentials = "omit" | "same-origin" | "include";
+type RequestDestination = "" | "document" | "sharedworker" | "subresource" | "unknown" | "worker";
+type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
+type RequestRedirect = "follow" | "error" | "manual";
+type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video";
+type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
+type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant";
+type VisibilityState = "hidden" | "visible" | "prerender" | "unloaded";
+type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
+type ClientType = "window" | "worker" | "sharedworker" | "all";
+type FrameType = "auxiliary" | "top-level" | "nested" | "none";
\ No newline at end of file
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 28d18ad5577..f4f1e66e1ff 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -273,6 +273,18 @@ namespace ts.server {
         }
     }
 
+    export interface ProjectServiceOptions {
+        host: ServerHost;
+        logger: Logger;
+        cancellationToken: HostCancellationToken;
+        useSingleInferredProject: boolean;
+        typingsInstaller: ITypingsInstaller;
+        eventHandler?: ProjectServiceEventHandler;
+        throttleWaitMilliseconds?: number;
+        globalPlugins?: string[];
+        pluginProbeLocations?: string[];
+    }
+
     export class ProjectService {
 
         public readonly typingsCache: TypingsCache;
@@ -320,19 +332,33 @@ namespace ts.server {
 
         public lastDeletedFile: ScriptInfo;
 
-        constructor(public readonly host: ServerHost,
-            public readonly logger: Logger,
-            public readonly cancellationToken: HostCancellationToken,
-            public readonly useSingleInferredProject: boolean,
-            readonly typingsInstaller: ITypingsInstaller = nullTypingsInstaller,
-            private readonly eventHandler?: ProjectServiceEventHandler,
-            public readonly throttleWaitMilliseconds?: number) {
+        public readonly host: ServerHost;
+        public readonly logger: Logger;
+        public readonly cancellationToken: HostCancellationToken;
+        public readonly useSingleInferredProject: boolean;
+        public readonly typingsInstaller: ITypingsInstaller;
+        public readonly throttleWaitMilliseconds?: number;
+        private readonly eventHandler?: ProjectServiceEventHandler;
 
-            Debug.assert(!!host.createHash, "'ServerHost.createHash' is required for ProjectService");
+        public readonly globalPlugins: ReadonlyArray<string>;
+        public readonly pluginProbeLocations: ReadonlyArray<string>;
 
-            this.toCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+        constructor(opts: ProjectServiceOptions) {
+            this.host = opts.host;
+            this.logger = opts.logger;
+            this.cancellationToken = opts.cancellationToken;
+            this.useSingleInferredProject = opts.useSingleInferredProject;
+            this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller;
+            this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds;
+            this.eventHandler = opts.eventHandler;
+            this.globalPlugins = opts.globalPlugins || emptyArray;
+            this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;
+
+            Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService");
+
+            this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);
             this.directoryWatchers = new DirectoryWatchers(this);
-            this.throttledOperations = new ThrottledOperations(host);
+            this.throttledOperations = new ThrottledOperations(this.host);
 
             this.typingsInstaller.attach(this);
 
@@ -344,7 +370,7 @@ namespace ts.server {
                 extraFileExtensions: []
             };
 
-            this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+            this.documentRegistry = createDocumentRegistry(this.host.useCaseSensitiveFileNames, this.host.getCurrentDirectory());
         }
 
         /* @internal */
diff --git a/src/server/project.ts b/src/server/project.ts
index e57e605d65b..b92e8e84972 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -843,7 +843,7 @@ namespace ts.server {
         /** Used for configured projects which may have multiple open roots */
         openRefCount = 0;
 
-        constructor(private configFileName: NormalizedPath,
+        constructor(configFileName: NormalizedPath,
             projectService: ProjectService,
             documentRegistry: ts.DocumentRegistry,
             hasExplicitListOfFiles: boolean,
@@ -863,28 +863,48 @@ namespace ts.server {
         enablePlugins() {
             const host = this.projectService.host;
             const options = this.getCompilerOptions();
-            const log = (message: string) => {
-                this.projectService.logger.info(message);
-            };
-
-            if (!(options.plugins && options.plugins.length)) {
-                this.projectService.logger.info("No plugins exist");
-                // No plugins
-                return;
-            }
 
             if (!host.require) {
                 this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                 return;
             }
 
-            for (const pluginConfigEntry of options.plugins) {
-                const searchPath = getDirectoryPath(this.configFileName);
-                const resolvedModule = <PluginModuleFactory>Project.resolveModule(pluginConfigEntry.name, searchPath, host, log);
-                if (resolvedModule) {
-                    this.enableProxy(resolvedModule, pluginConfigEntry);
+            // Search our peer node_modules, then any globally-specified probe paths
+            // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
+            const searchPaths = [combinePaths(host.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations];
+
+            // Enable tsconfig-specified plugins
+            if (options.plugins) {
+                for (const pluginConfigEntry of options.plugins) {
+                    this.enablePlugin(pluginConfigEntry, searchPaths);
                 }
             }
+
+            if (this.projectService.globalPlugins) {
+                // Enable global plugins with synthetic configuration entries
+                for (const globalPluginName of this.projectService.globalPlugins) {
+                    // Skip already-locally-loaded plugins
+                    if (options.plugins && options.plugins.some(p => p.name === globalPluginName)) continue;
+
+                    // Provide global: true so plugins can detect why they can't find their config
+                    this.enablePlugin({ name: globalPluginName, global: true } as PluginImport, searchPaths);
+                }
+            }
+        }
+
+        private enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[]) {
+            const log = (message: string) => {
+                this.projectService.logger.info(message);
+            };
+
+            for (const searchPath of searchPaths) {
+                const resolvedModule = <PluginModuleFactory>Project.resolveModule(pluginConfigEntry.name, searchPath, this.projectService.host, log);
+                if (resolvedModule) {
+                    this.enableProxy(resolvedModule, pluginConfigEntry);
+                    return;
+                }
+            }
+            this.projectService.logger.info(`Couldn't find ${pluginConfigEntry.name} anywhere in paths: ${searchPaths.join(",")}`);
         }
 
         private enableProxy(pluginModuleFactory: PluginModuleFactory, configEntry: PluginImport) {
diff --git a/src/server/server.ts b/src/server/server.ts
index 704193210e3..433c7e16ab1 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -3,6 +3,20 @@
 /// <reference path="session.ts" />
 
 namespace ts.server {
+    interface IOSessionOptions {
+        host: ServerHost;
+        cancellationToken: ServerCancellationToken;
+        canUseEvents: boolean;
+        installerEventPort: number;
+        useSingleInferredProject: boolean;
+        disableAutomaticTypingAcquisition: boolean;
+        globalTypingsCacheLocation: string;
+        logger: Logger;
+        typingSafeListLocation: string;
+        telemetryEnabled: boolean;
+        globalPlugins: string[];
+        pluginProbeLocations: string[];
+    }
 
     const net: {
         connect(options: { port: number }, onConnect?: () => void): NodeSocket
@@ -373,34 +387,25 @@ namespace ts.server {
     }
 
     class IOSession extends Session {
-        constructor(
-            host: ServerHost,
-            cancellationToken: ServerCancellationToken,
-            installerEventPort: number,
-            canUseEvents: boolean,
-            useSingleInferredProject: boolean,
-            disableAutomaticTypingAcquisition: boolean,
-            globalTypingsCacheLocation: string,
-            typingSafeListLocation: string,
-            telemetryEnabled: boolean,
-            logger: server.Logger) {
-                const typingsInstaller = disableAutomaticTypingAcquisition
-                    ? undefined
-                    : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, host.newLine);
+        constructor(options: IOSessionOptions) {
+            const { host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, canUseEvents } = options;
+            const typingsInstaller = disableAutomaticTypingAcquisition
+                ? undefined
+                : new NodeTypingsInstaller(telemetryEnabled, logger, host, installerEventPort, globalTypingsCacheLocation, typingSafeListLocation, host.newLine);
 
-                super(
-                    host,
-                    cancellationToken,
-                    useSingleInferredProject,
-                    typingsInstaller || nullTypingsInstaller,
-                    Buffer.byteLength,
-                    process.hrtime,
-                    logger,
-                    canUseEvents);
+            super({
+                host,
+                cancellationToken,
+                useSingleInferredProject,
+                typingsInstaller: typingsInstaller || nullTypingsInstaller,
+                byteLength: Buffer.byteLength,
+                hrtime: process.hrtime,
+                logger,
+                canUseEvents});
 
-                if (telemetryEnabled && typingsInstaller) {
-                    typingsInstaller.setTelemetrySender(this);
-                }
+            if (telemetryEnabled && typingsInstaller) {
+                typingsInstaller.setTelemetrySender(this);
+            }
         }
 
         exit() {
@@ -735,21 +740,29 @@ namespace ts.server {
 
     const typingSafeListLocation = findArgument("--typingSafeListLocation");
 
+    const globalPlugins = (findArgument("--globalPlugins") || "").split(",");
+    const pluginProbeLocations = (findArgument("--pluginProbeLocations") || "").split(",");
+
     const useSingleInferredProject = hasArgument("--useSingleInferredProject");
     const disableAutomaticTypingAcquisition = hasArgument("--disableAutomaticTypingAcquisition");
     const telemetryEnabled = hasArgument(Arguments.EnableTelemetry);
 
-    const ioSession = new IOSession(
-        sys,
+    const options: IOSessionOptions = {
+        host: sys,
         cancellationToken,
-        eventPort,
-        /*canUseEvents*/ eventPort === undefined,
+        installerEventPort: eventPort,
+        canUseEvents: eventPort === undefined,
         useSingleInferredProject,
         disableAutomaticTypingAcquisition,
-        getGlobalTypingsCacheLocation(),
+        globalTypingsCacheLocation: getGlobalTypingsCacheLocation(),
         typingSafeListLocation,
         telemetryEnabled,
-        logger);
+        logger,
+        globalPlugins,
+        pluginProbeLocations
+    };
+
+    const ioSession = new IOSession(options);
     process.on("uncaughtException", function (err: Error) {
         ioSession.logError(err, "unknown");
     });
diff --git a/src/server/session.ts b/src/server/session.ts
index 26dbceece45..d4dc371b16b 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -319,6 +319,22 @@ namespace ts.server {
         }
     }
 
+    export interface SessionOptions {
+        host: ServerHost;
+        cancellationToken: ServerCancellationToken;
+        useSingleInferredProject: boolean;
+        typingsInstaller: ITypingsInstaller;
+        byteLength: (buf: string, encoding?: string) => number;
+        hrtime: (start?: number[]) => number[];
+        logger: Logger;
+        canUseEvents: boolean;
+        eventHandler?: ProjectServiceEventHandler;
+        throttleWaitMilliseconds?: number;
+
+        globalPlugins?: string[];
+        pluginProbeLocations?: string[];
+    }
+
     export class Session implements EventSender {
         private readonly gcTimer: GcTimer;
         protected projectService: ProjectService;
@@ -327,22 +343,29 @@ namespace ts.server {
         private currentRequestId: number;
         private errorCheck: MultistepOperation;
 
-        private eventHander: ProjectServiceEventHandler;
+        private eventHandler: ProjectServiceEventHandler;
 
-        constructor(
-            private host: ServerHost,
-            private readonly cancellationToken: ServerCancellationToken,
-            useSingleInferredProject: boolean,
-            protected readonly typingsInstaller: ITypingsInstaller,
-            private byteLength: (buf: string, encoding?: string) => number,
-            private hrtime: (start?: number[]) => number[],
-            protected logger: Logger,
-            protected readonly canUseEvents: boolean,
-            eventHandler?: ProjectServiceEventHandler,
-            private readonly throttleWaitMilliseconds?: number) {
+        private host: ServerHost;
+        private readonly cancellationToken: ServerCancellationToken;
+        protected readonly typingsInstaller: ITypingsInstaller;
+        private byteLength: (buf: string, encoding?: string) => number;
+        private hrtime: (start?: number[]) => number[];
+        protected logger: Logger;
+        private canUseEvents: boolean;
 
-            this.eventHander = canUseEvents
-                ? eventHandler || (event => this.defaultEventHandler(event))
+        constructor(opts: SessionOptions) {
+            this.host = opts.host;
+            this.cancellationToken = opts.cancellationToken;
+            this.typingsInstaller = opts.typingsInstaller;
+            this.byteLength = opts.byteLength;
+            this.hrtime = opts.hrtime;
+            this.logger = opts.logger;
+            this.canUseEvents = opts.canUseEvents;
+
+            const { throttleWaitMilliseconds } = opts;
+
+            this.eventHandler = this.canUseEvents
+                ? opts.eventHandler || (event => this.defaultEventHandler(event))
                 : undefined;
 
             const multistepOperationHost: MultistepOperationHost = {
@@ -351,11 +374,22 @@ namespace ts.server {
                 getServerHost: () => this.host,
                 logError: (err, cmd) => this.logError(err, cmd),
                 sendRequestCompletedEvent: requestId => this.sendRequestCompletedEvent(requestId),
-                isCancellationRequested: () => cancellationToken.isCancellationRequested()
+                isCancellationRequested: () => this.cancellationToken.isCancellationRequested()
             };
             this.errorCheck = new MultistepOperation(multistepOperationHost);
-            this.projectService = new ProjectService(host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, this.eventHander, this.throttleWaitMilliseconds);
-            this.gcTimer = new GcTimer(host, /*delay*/ 7000, logger);
+            const settings: ProjectServiceOptions = {
+                host: this.host,
+                logger: this.logger,
+                cancellationToken: this.cancellationToken,
+                useSingleInferredProject: opts.useSingleInferredProject,
+                typingsInstaller: this.typingsInstaller,
+                throttleWaitMilliseconds,
+                eventHandler: this.eventHandler,
+                globalPlugins: opts.globalPlugins,
+                pluginProbeLocations: opts.pluginProbeLocations
+            };
+            this.projectService = new ProjectService(settings);
+            this.gcTimer = new GcTimer(this.host, /*delay*/ 7000, this.logger);
         }
 
         private sendRequestCompletedEvent(requestId: number): void {
@@ -947,8 +981,8 @@ namespace ts.server {
          */
         private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind) {
             const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind);
-            if (this.eventHander) {
-                this.eventHander({
+            if (this.eventHandler) {
+                this.eventHandler({
                     eventName: "configFileDiag",
                     data: { triggerFile: fileName, configFileName, diagnostics: configFileErrors || [] }
                 });
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 7308ad235fc..047e665d7a5 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -17,34 +17,22 @@ namespace ts.DocumentHighlights {
     }
 
     function getSemanticDocumentHighlights(node: Node, typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
-        const context = new FindAllReferences.DefaultFindReferencesContext(typeChecker, cancellationToken);
-        const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(context, node, sourceFilesToSearch);
-        return referencedSymbols && convertReferencedSymbols(referencedSymbols);
+        const referenceEntries = FindAllReferences.getReferenceEntriesForNode(node, sourceFilesToSearch, typeChecker, cancellationToken);
+        return referenceEntries && convertReferencedSymbols(referenceEntries);
     }
 
-    function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
-        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,
-                    isInString: referenceEntry.isInString
-                });
+    function convertReferencedSymbols(referenceEntries: FindAllReferences.Entry[]): DocumentHighlights[] {
+        const fileNameToDocumentHighlights = createMap<HighlightSpan[]>();
+        for (const entry of referenceEntries) {
+            const { fileName, span } = FindAllReferences.toHighlightSpan(entry);
+            let highlightSpans = fileNameToDocumentHighlights.get(fileName);
+            if (!highlightSpans) {
+                fileNameToDocumentHighlights.set(fileName, highlightSpans = []);
             }
+            highlightSpans.push(span);
         }
 
-        return result;
+        return arrayFrom(fileNameToDocumentHighlights.entries(), ([fileName, highlightSpans ]) => ({ fileName, highlightSpans }));
     }
 
     function getSyntacticDocumentHighlights(node: Node, sourceFile: SourceFile): DocumentHighlights[] {
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index caa68470b88..98e601ebb06 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -1,148 +1,302 @@
+/// <reference path="./importTracker.ts" />
+
 /* @internal */
 namespace ts.FindAllReferences {
-
-    export interface FindReferencesContext<T extends DocumentSpan> {
-        readonly typeChecker: TypeChecker;
-        readonly cancellationToken: CancellationToken;
-        getReferenceEntryFromNode(node: Node, isInString?: boolean): T;
-        getReferenceEntryForSpanInFile(fileName: string, span: TextSpan): T;
+    export interface SymbolAndEntries {
+        definition: Definition | undefined;
+        references: Entry[];
     }
 
-    export class DefaultFindReferencesContext implements FindReferencesContext<ReferenceEntry>  {
-        constructor(readonly typeChecker: TypeChecker, readonly cancellationToken: CancellationToken) {
+    type Definition =
+        | { type: "symbol"; symbol: Symbol; node: Node }
+        | { type: "label"; node: Identifier }
+        | { type: "keyword"; node: ts.Node }
+        | { type: "this"; node: ts.Node }
+        | { type: "string"; node: ts.StringLiteral };
+
+    export type Entry = NodeEntry | SpanEntry;
+    export interface NodeEntry {
+        type: "node";
+        node: Node;
+        isInString?: true;
+    }
+    interface SpanEntry {
+        type: "span";
+        fileName: string;
+        textSpan: TextSpan;
+    }
+    export function nodeEntry(node: ts.Node, isInString?: true): NodeEntry {
+        return { type: "node", node, isInString };
+    }
+
+    export interface Options {
+        readonly findInStrings?: boolean;
+        readonly findInComments?: boolean;
+        /**
+         * True if we are renaming the symbol.
+         * If so, we will find fewer references -- if it is referenced by several different names, we sill only find references for the original name.
+         */
+        readonly isForRename?: boolean;
+        /** True if we are searching for implementations. We will have a different method of adding references if so. */
+        readonly implementations?: boolean;
+    }
+
+    export function findReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ReferencedSymbol[] | undefined {
+        const referencedSymbols = findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position);
+
+        if (!referencedSymbols || !referencedSymbols.length) {
+            return undefined;
         }
-        getReferenceEntryFromNode(node: Node, isInString?: boolean): ReferenceEntry {
-            const reference = getReferenceEntryFromNode(node);
-            if (isInString) {
-                reference.isInString = true;
+
+        const out: ReferencedSymbol[] = [];
+        for (const { definition, references } of referencedSymbols) {
+            // Only include referenced symbols that have a valid definition.
+            if (definition) {
+                out.push({ definition: definitionToReferencedSymbolDefinitionInfo(definition, checker), references: references.map(toReferenceEntry) });
             }
-            return reference;
         }
-        getReferenceEntryForSpanInFile(fileName: string, textSpan: TextSpan): ReferenceEntry {
-            return { textSpan, fileName, isWriteAccess: false, isDefinition: false };
+
+        return out;
+    }
+
+    export function getImplementationsAtPosition(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number): ImplementationLocation[] {
+        const node = getTouchingPropertyName(sourceFile, position);
+        const referenceEntries = getImplementationReferenceEntries(checker, cancellationToken, sourceFiles, node);
+        return map(referenceEntries, entry => toImplementationLocation(entry, checker));
+    }
+
+    function getImplementationReferenceEntries(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): Entry[] | undefined {
+        // If invoked directly on a shorthand property assignment, then return
+        // the declaration of the symbol being assigned (not the symbol being assigned to).
+        if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            const result: NodeEntry[] = [];
+            Core.getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, node => result.push(nodeEntry(node)));
+            return result;
+        }
+        else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) {
+            // References to and accesses on the super keyword only have one possible implementation, so no
+            // need to "Find all References"
+            const symbol = typeChecker.getSymbolAtLocation(node);
+            return symbol.valueDeclaration && [nodeEntry(symbol.valueDeclaration)];
+        }
+        else {
+            // Perform "Find all References" and retrieve only those that are implementations
+            return getReferenceEntriesForNode(node, sourceFiles, typeChecker, cancellationToken, { implementations: true });
         }
     }
 
-    export class FindImplementationsContext implements FindReferencesContext<ImplementationLocation> {
-        constructor(readonly typeChecker: TypeChecker, readonly cancellationToken: CancellationToken) {
+    export function findReferencedEntries(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): ReferenceEntry[] | undefined {
+        const x = flattenEntries(findAllReferencedSymbols(checker, cancellationToken, sourceFiles, sourceFile, position, options));
+        return map(x, toReferenceEntry);
+    }
+
+    export function getReferenceEntriesForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): Entry[] | undefined {
+        return flattenEntries(Core.getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options));
+    }
+
+    function findAllReferencedSymbols(checker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], sourceFile: SourceFile, position: number, options?: Options): SymbolAndEntries[] | undefined {
+        const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
+        return Core.getReferencedSymbolsForNode(node, sourceFiles, checker, cancellationToken, options);
+    }
+
+    function flattenEntries(referenceSymbols: SymbolAndEntries[]): Entry[] {
+        return referenceSymbols && flatMap(referenceSymbols, r => r.references);
+    }
+
+    function definitionToReferencedSymbolDefinitionInfo(def: Definition, checker: TypeChecker): ReferencedSymbolDefinitionInfo | undefined {
+        const info = (() => {
+            switch (def.type) {
+                case "symbol": {
+                    const { symbol, node } = def;
+                    const declarations = symbol.declarations;
+                    if (!declarations || declarations.length === 0) {
+                        return undefined;
+                    }
+                    const { displayParts, kind } = getDefinitionKindAndDisplayParts(symbol, node, checker);
+                    const name = displayParts.map(p => p.text).join("");
+                    return { node, name, kind, displayParts };
+                }
+                case "label": {
+                    const { node } = def;
+                    return { node, name: node.text, kind: ScriptElementKind.label, displayParts: [displayPart(node.text, SymbolDisplayPartKind.text)] };
+                }
+                case "keyword": {
+                    const { node } = def;
+                    const name = tokenToString(node.kind);
+                    return { node, name, kind: ScriptElementKind.keyword, displayParts: [{ text: name, kind: ScriptElementKind.keyword }] };
+                }
+                case "this": {
+                    const { node } = def;
+                    const symbol = checker.getSymbolAtLocation(node);
+                    const displayParts = symbol && SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(
+                        checker, symbol, node.getSourceFile(), getContainerNode(node), node).displayParts;
+                    return { node, name: "this", kind: ScriptElementKind.variableElement, displayParts };
+                }
+                case "string": {
+                    const { node } = def;
+                    return { node, name: node.text, kind: ScriptElementKind.variableElement, displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)] };
+                }
+            }
+        })();
+
+        if (!info) {
+            return undefined;
         }
-        getReferenceEntryFromNode(node: Node): ImplementationLocation {
-            const entry = <ImplementationLocation><any>getReferenceEntryFromNode(node);
-            const symbol = this.typeChecker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node);
-            if (symbol) {
-                const def = getDefinition(symbol, node, this.typeChecker);
-                entry.kind = def.kind;
-                entry.displayParts = def.displayParts;
-            }
-            else if (node.kind === SyntaxKind.ObjectLiteralExpression) {
-                entry.kind = ScriptElementKind.interfaceElement;
-                entry.displayParts = [punctuationPart(SyntaxKind.OpenParenToken), textPart("object literal"), punctuationPart(SyntaxKind.CloseParenToken)];
-            }
-            else if (node.kind === SyntaxKind.ClassExpression) {
-                entry.kind = ScriptElementKind.localClassElement;
-                entry.displayParts = [punctuationPart(SyntaxKind.OpenParenToken), textPart("anonymous local class"), punctuationPart(SyntaxKind.CloseParenToken)];
-            }
-            else {
-                entry.kind = getNodeKind(node);
-                entry.displayParts = [];
-            }
-            return entry;
+
+        const { node, name, kind, displayParts } = info;
+        const sourceFile = node.getSourceFile();
+        return {
+            containerKind: "",
+            containerName: "",
+            fileName: sourceFile.fileName,
+            kind,
+            name,
+            textSpan: createTextSpanFromNode(node, sourceFile),
+            displayParts
+        };
+    }
+
+    function getDefinitionKindAndDisplayParts(symbol: Symbol, node: Node, checker: TypeChecker): { displayParts: SymbolDisplayPart[], kind: string } {
+        const { displayParts, symbolKind } =
+            SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), getContainerNode(node), node);
+        return { displayParts, kind: symbolKind };
+    }
+
+    function toReferenceEntry(entry: Entry): ReferenceEntry {
+        if (entry.type === "span") {
+            return { textSpan: entry.textSpan, fileName: entry.fileName, isWriteAccess: false, isDefinition: false };
         }
-        getReferenceEntryForSpanInFile(fileName: string, textSpan: TextSpan): ImplementationLocation {
+
+        const { node, isInString } = entry;
+        return {
+            fileName: node.getSourceFile().fileName,
+            textSpan: getTextSpan(node),
+            isWriteAccess: isWriteAccess(node),
+            isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node),
+            isInString
+        };
+    }
+
+    function toImplementationLocation(entry: Entry, checker: ts.TypeChecker): ImplementationLocation {
+        if (entry.type === "node") {
+            const { node } = entry;
+            return { textSpan: getTextSpan(node), fileName: node.getSourceFile().fileName, ...implementationKindDisplayParts(node, checker) };
+        } else {
+            const { textSpan, fileName } = entry;
             return { textSpan, fileName, kind: ScriptElementKind.unknown, displayParts: [] };
         }
     }
 
-    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(new DefaultFindReferencesContext(typeChecker, cancellationToken), node, sourceFiles, findInStrings, findInComments, isForRename);
+    function implementationKindDisplayParts(node: ts.Node, checker: ts.TypeChecker): { kind: string, displayParts: SymbolDisplayPart[] } {
+        const symbol = checker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node);
+        if (symbol) {
+            return getDefinitionKindAndDisplayParts(symbol, node, checker);
+        }
+        else if (node.kind === SyntaxKind.ObjectLiteralExpression) {
+            return {
+                kind: ScriptElementKind.interfaceElement,
+                displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("object literal"), punctuationPart(SyntaxKind.CloseParenToken)]
+            };
+        }
+        else if (node.kind === SyntaxKind.ClassExpression) {
+            return {
+                kind: ScriptElementKind.localClassElement,
+                displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("anonymous local class"), punctuationPart(SyntaxKind.CloseParenToken)]
+            };
+        }
+        else {
+            return { kind: getNodeKind(node), displayParts: [] };
+        }
     }
 
-    export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
-        return referenceSymbols && flatMap(referenceSymbols, r => r.references);
+    export function toHighlightSpan(entry: FindAllReferences.Entry): { fileName: string, span: HighlightSpan } {
+        if (entry.type === "span") {
+            const { fileName, textSpan } = entry;
+            return { fileName, span: { textSpan, kind: HighlightSpanKind.reference } };
+        }
+
+        const { node, isInString } = entry;
+        const fileName = entry.node.getSourceFile().fileName;
+        const writeAccess = isWriteAccess(node);
+        const span: HighlightSpan = {
+            textSpan: getTextSpan(node),
+            kind: writeAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference,
+            isInString
+        };
+        return { fileName, span };
     }
 
-    export function getReferencedSymbolsForNode<T extends DocumentSpan>(context: FindReferencesContext<T>, node: Node, sourceFiles: SourceFile[], findInStrings?: boolean, findInComments?: boolean, isForRename?: boolean, implementations?: boolean): ReferencedSymbolOf<T>[] | undefined {
-        if (!implementations) {
-            const special = getReferencedSymbolsSpecial(node, sourceFiles, context);
+    function getTextSpan(node: Node): TextSpan {
+        let start = node.getStart();
+        let end = node.getEnd();
+        if (node.kind === SyntaxKind.StringLiteral) {
+            start += 1;
+            end -= 1;
+        }
+        return createTextSpanFromBounds(start, end);
+    }
+
+    /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */
+    function isWriteAccess(node: Node): boolean {
+        if (node.kind === SyntaxKind.Identifier && isDeclarationName(node)) {
+            return true;
+        }
+
+        const parent = node.parent;
+        if (parent) {
+            if (parent.kind === SyntaxKind.PostfixUnaryExpression || parent.kind === SyntaxKind.PrefixUnaryExpression) {
+                return true;
+            }
+            else if (parent.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>parent).left === node) {
+                const operator = (<BinaryExpression>parent).operatorToken.kind;
+                return SyntaxKind.FirstAssignment <= operator && operator <= SyntaxKind.LastAssignment;
+            }
+        }
+
+        return false;
+    }
+}
+
+/** Encapsulates the core find-all-references algorithm. */
+/* @internal */
+namespace ts.FindAllReferences.Core {
+    /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */
+    export function getReferencedSymbolsForNode(node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options = {}): SymbolAndEntries[] | undefined {
+        if (node.kind === ts.SyntaxKind.SourceFile) {
+            return undefined;
+        }
+
+        if (!options.implementations) {
+            const special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken);
             if (special) {
                 return special;
             }
         }
-        const { typeChecker, cancellationToken } = context;
 
-        // `getSymbolAtLocation` normally returns the symbol of the class when given the constructor keyword,
-        // so we have to specify that we want the constructor symbol.
-        let symbol = typeChecker.getSymbolAtLocation(node);
+        const symbol = checker.getSymbolAtLocation(node);
 
         // Could not find a symbol e.g. unknown identifier
         if (!symbol) {
-            if (!implementations && node.kind === SyntaxKind.StringLiteral) {
-                return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, context);
+            // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial.
+            if (!options.implementations && node.kind === SyntaxKind.StringLiteral) {
+                return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles, cancellationToken);
             }
             // Can't have references to something that we have no symbol for.
             return undefined;
         }
 
-        const declarations = symbol.declarations;
-
         // The symbol was an internal symbol and does not have a declaration e.g. undefined symbol
-        if (!declarations || !declarations.length) {
+        if (!symbol.declarations || !symbol.declarations.length) {
             return undefined;
         }
 
-        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);
-        }
-
-        // Compute the meaning from the location and the symbol it references
-        const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
-
-        const result: ReferencedSymbolOf<T>[] = [];
-        // Maps from a symbol ID to the ReferencedSymbol entry in 'result'.
-        const symbolToIndex: number[] = [];
-        const inheritsFromCache: Map<boolean> = createMap<boolean>();
-
-        // 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));
-
-        // 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);
-        if (scope) {
-            getRefs(scope, declaredName);
-        }
-        else {
-            const isDefault = isExportDefaultSymbol(symbol);
-            const internedName = isDefault ? symbol.valueDeclaration.localSymbol.name : getInternedName(symbol, node);
-            for (const sourceFile of sourceFiles) {
-                cancellationToken.throwIfCancellationRequested();
-                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, context, searchSymbols, inheritsFromCache);
-        }
+        return getReferencedSymbolsForSymbol(symbol, node, sourceFiles, checker, cancellationToken, options);
     }
 
     /** getReferencedSymbols for special node kinds. */
-    function getReferencedSymbolsSpecial<T extends DocumentSpan>(node: Node, sourceFiles: SourceFile[], context: FindReferencesContext<T>): ReferencedSymbolOf<T>[] | undefined {
+    function getReferencedSymbolsSpecial(node: Node, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] | undefined {
         if (isTypeKeyword(node.kind)) {
-            return getAllReferencesForKeyword(context, sourceFiles, node.kind);
+            return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken);
         }
 
         // Labels
@@ -151,152 +305,275 @@ 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, context);
+                return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition);
             }
             else {
                 // it is a label definition and not a target, search within the parent labeledStatement
-                return getLabelReferencesInNode(node.parent, <Identifier>node, context);
+                return getLabelReferencesInNode(node.parent, <Identifier>node);
             }
         }
 
         if (isThis(node)) {
-            return getReferencesForThisKeyword(node, sourceFiles, context);
+            return getReferencesForThisKeyword(node, sourceFiles, cancellationToken);
         }
 
         if (node.kind === SyntaxKind.SuperKeyword) {
-            return getReferencesForSuperKeyword(node, context);
+            return getReferencesForSuperKeyword(node);
         }
 
         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 };
-            }
+    /** Core find-all-references algorithm for a normal symbol. */
+    function getReferencedSymbolsForSymbol(symbol: Symbol, node: Node, sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] {
+        symbol = skipPastExportOrImportSpecifier(symbol, node, checker);
 
-            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 };
-            }
+        // Compute the meaning from the location and the symbol it references
+        const searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), symbol.declarations);
 
-            if (ts.isShorthandAmbientModuleSymbol(aliasedSymbol)) {
-                return { symbol, shorthandModuleSymbol: aliasedSymbol };
-            }
+        const result: SymbolAndEntries[] = [];
+        const state = createState(sourceFiles, node, checker, cancellationToken, searchMeaning, options, result);
+        const search = state.createSearch(node, symbol, /*comingFrom*/ undefined, { allSearchSymbols: populateSearchSymbolSet(symbol, node, checker, options.implementations) });
 
-            symbol = aliasedSymbol;
+        // 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);
+        if (scope) {
+            getReferencesInContainer(scope, scope.getSourceFile(), search, state);
         }
+        else {
+            // Global search
+            for (const sourceFile of state.sourceFiles) {
+                state.cancellationToken.throwIfCancellationRequested();
+                searchForName(sourceFile, search, state);
+            }
+        }
+
+        return result;
     }
 
-    function sourceFileHasName(sourceFile: SourceFile, name: string): boolean {
-        return getNameTable(sourceFile).get(name) !== undefined;
+    /** Handle a few special cases relating to export/import specifiers. */
+    function skipPastExportOrImportSpecifier(symbol: Symbol, node: Node, checker: TypeChecker): Symbol {
+        const { parent } = node;
+        if (isExportSpecifier(parent)) {
+            return getLocalSymbolForExportSpecifier(node as Identifier, symbol, parent, checker);
+        }
+        if (isImportSpecifier(parent) && parent.propertyName === node) {
+            // We're at `foo` in `import { foo as bar }`. Probably intended to find all refs on the original, not just on the import.
+            return checker.getImmediateAliasedSymbol(symbol);
+        }
+
+        return symbol;
     }
 
     /**
-     * Given a symbol, see if any of the imports in a source file reference it.
-     * Only call this if `symbol` is a default export.
+     * Symbol that is currently being searched for.
+     * This will be replaced if we find an alias for the symbol.
      */
-    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 = defaultName && checker.getAliasedSymbol(checker.getSymbolAtLocation(defaultName));
-            if (symbol === defaultReferencedSymbol) {
-                return defaultName.text;
-            }
-        }
-        return undefined;
+    interface Search {
+        /** If coming from an export, we will not recursively search for the imported symbol (since that's where we came from). */
+        readonly comingFrom?: ImportExport;
+
+        readonly location: Node;
+        readonly symbol: Symbol;
+        readonly text: string;
+        readonly escapedText: string;
+        /** Only set if `options.implementations` is true. These are the symbols checked to get the implementations of a property access. */
+        readonly parents: Symbol[] | undefined;
+
+        /**
+         * Whether a symbol is in the search set.
+         * Do not compare directly to `symbol` because there may be related symbols to search for. See `populateSearchSymbolSet`.
+         */
+        includes(symbol: Symbol): boolean;
     }
 
-    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("");
-        const declarations = symbol.declarations;
-        if (!declarations || declarations.length === 0) {
-            return undefined;
-        }
+    /**
+     * Holds all state needed for the finding references.
+     * Unlike `Search`, there is only one `State`.
+     */
+    interface State extends Options {
+        /** True if we're searching for constructor references. */
+        readonly isForConstructor: boolean;
+
+        readonly sourceFiles: SourceFile[];
+        readonly checker: TypeChecker;
+        readonly cancellationToken: CancellationToken;
+        readonly searchMeaning: SemanticMeaning;
+
+        /** Cache for `explicitlyinheritsFrom`. */
+        readonly inheritsFromCache: Map<boolean>;
+
+        /** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */
+        getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult;
+
+        /** @param allSearchSymbols set of additinal symbols for use by `includes`. */
+        createSearch(location: Node, symbol: Symbol, comingFrom: ImportExport | undefined, searchOptions?: { text?: string, allSearchSymbols?: Symbol[] }): Search;
+
+        /**
+         * Callback to add references for a particular searched symbol.
+         * This initializes a reference group, so only call this if you will add at least one reference.
+         */
+        referenceAdder(searchSymbol: Symbol, searchLocation: Node): (node: Node) => void;
+
+        /** Add a reference with no associated definition. */
+        addStringOrCommentReference(fileName: string, textSpan: TextSpan): void;
+
+        /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */
+        markSearchedSymbol(sourceFile: SourceFile, symbol: Symbol): boolean;
+
+        /**
+         * 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.
+         */
+        markSeenContainingTypeReference(containingTypeReference: Node): boolean;
+
+        /**
+         * It's possible that we will encounter the right side of `export { foo as bar } from "x";` more than once.
+         * For example:
+         *     // b.ts
+         *     export { foo as bar } from "./a";
+         *     import { bar } from "./b";
+         *
+         * Normally at `foo as bar` we directly add `foo` and do not locally search for it (since it doesn't declare a local).
+         * But another reference to it may appear in the same source file.
+         * See `tests/cases/fourslash/transitiveExportImports3.ts`.
+         */
+        markSeenReExportRHS(rhs: Identifier): boolean;
+    }
+
+    function createState(sourceFiles: SourceFile[], originalLocation: Node, checker: TypeChecker, cancellationToken: CancellationToken, searchMeaning: SemanticMeaning, options: Options, result: Push<SymbolAndEntries>): State {
+        const symbolIdToReferences: Entry[][] = [];
+        const inheritsFromCache = createMap<boolean>();
+        // Source file ID → symbol ID → Whether the symbol has been searched for in the source file.
+        const sourceFileToSeenSymbols: Array<Array<true>> = [];
+        const isForConstructor = originalLocation.kind === SyntaxKind.ConstructorKeyword;
+        let importTracker: ImportTracker | undefined;
 
         return {
-            containerKind: "",
-            containerName: "",
-            name,
-            kind: symbolKind,
-            fileName: declarations[0].getSourceFile().fileName,
-            textSpan: createTextSpan(declarations[0].getStart(), 0),
-            displayParts
+            ...options,
+            sourceFiles, isForConstructor, checker, cancellationToken, searchMeaning, inheritsFromCache, getImportSearches, createSearch, referenceAdder, addStringOrCommentReference,
+            markSearchedSymbol, markSeenContainingTypeReference: nodeSeenTracker(), markSeenReExportRHS: nodeSeenTracker(),
         };
-    }
 
-    function getAliasSymbolForPropertyNameSymbol(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol | undefined {
-        if (!(symbol.flags & SymbolFlags.Alias)) {
-            return undefined;
+        function getImportSearches(exportSymbol: Symbol, exportInfo: ExportInfo): ImportsResult {
+            if (!importTracker) importTracker = createImportTracker(sourceFiles, checker, cancellationToken);
+            return importTracker(exportSymbol, exportInfo, options.isForRename);
         }
 
-        // Default import get alias
-        const defaultImport = getDeclarationOfKind(symbol, SyntaxKind.ImportClause);
-        if (defaultImport) {
-            return typeChecker.getAliasedSymbol(symbol);
+        function createSearch(location: Node, symbol: Symbol, comingFrom: ImportExport, searchOptions: { text?: string, allSearchSymbols?: Symbol[] } = {}): Search {
+            // Note: if this is an external module symbol, the name doesn't include quotes.
+            const { text = stripQuotes(getDeclaredName(checker, symbol, location)), allSearchSymbols = undefined } = searchOptions;
+            const escapedText = escapeIdentifier(text);
+            const parents = options.implementations && getParentSymbolsOfPropertyAccess(location, symbol, checker);
+            return { location, symbol, comingFrom, text, escapedText, parents, includes };
+
+            function includes(referenceSymbol: Symbol): boolean {
+                return allSearchSymbols ? contains(allSearchSymbols, referenceSymbol) : referenceSymbol === 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 referenceAdder(referenceSymbol: Symbol, searchLocation: Node): (node: Node) => void {
+            const symbolId = getSymbolId(referenceSymbol);
+            let references = symbolIdToReferences[symbolId];
+            if (!references) {
+                references = symbolIdToReferences[symbolId] = [];
+                result.push({ definition: { type: "symbol", symbol: referenceSymbol, node: searchLocation }, references });
+            }
+            return node => references.push(nodeEntry(node));
+        }
+
+        function addStringOrCommentReference(fileName: string, textSpan: TextSpan): void {
+            result.push({
+                definition: undefined,
+                references: [{ type: "span", fileName, textSpan }]
+            });
+        }
+
+        function markSearchedSymbol(sourceFile: SourceFile, symbol: Symbol): boolean {
+            const sourceId = getNodeId(sourceFile);
+            const symbolId = getSymbolId(symbol);
+            const seenSymbols = sourceFileToSeenSymbols[sourceId] || (sourceFileToSeenSymbols[sourceId] = []);
+            return !seenSymbols[symbolId] && (seenSymbols[symbolId] = true);
         }
     }
 
-    function followAliasIfNecessary(symbol: Symbol, location: Node, typeChecker: TypeChecker): Symbol {
-        return getAliasSymbolForPropertyNameSymbol(symbol, location, typeChecker) || symbol;
+    /** Search for all imports of a given exported symbol using `State.getImportSearches`. */
+    function searchForImportsOfExport(exportLocation: Node, exportSymbol: Symbol, exportInfo: ExportInfo, state: State): void {
+        const { importSearches, singleReferences, indirectUsers } = state.getImportSearches(exportSymbol, exportInfo);
+
+        // For `import { foo as bar }` just add the reference to `foo`, and don't otherwise search in the file.
+        if (singleReferences.length) {
+            const addRef = state.referenceAdder(exportSymbol, exportLocation);
+            for (const singleRef of singleReferences) {
+                addRef(singleRef);
+            }
+        }
+
+        // For each import, find all references to that import in its source file.
+        for (const [importLocation, importSymbol] of importSearches) {
+            getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, ImportExport.Export), state);
+        }
+
+        if (indirectUsers.length) {
+            let indirectSearch: Search | undefined;
+            switch (exportInfo.exportKind) {
+                case ExportKind.Named:
+                    indirectSearch = state.createSearch(exportLocation, exportSymbol, ImportExport.Export);
+                    break;
+                case ExportKind.Default:
+                    // Search for a property access to '.default'. This can't be renamed.
+                    indirectSearch = state.isForRename ? undefined : state.createSearch(exportLocation, exportSymbol, ImportExport.Export, { text: "default" });
+                    break;
+                case ExportKind.ExportEquals:
+                    break;
+            }
+            if (indirectSearch) {
+                for (const indirectUser of indirectUsers) {
+                    searchForName(indirectUser, indirectSearch, state);
+                }
+            }
+        }
     }
 
-    function getPropertySymbolOfDestructuringAssignment(location: Node, typeChecker: TypeChecker) {
+    // Go to the symbol we imported from and find references for it.
+    function searchForImportedSymbol(symbol: Symbol, state: State): void {
+        for (const declaration of symbol.declarations) {
+            getReferencesInSourceFile(declaration.getSourceFile(), state.createSearch(declaration, symbol, ImportExport.Import), state);
+        }
+    }
+
+    /** Search for all occurences of an identifier in a source file (and filter out the ones that match). */
+    function searchForName(sourceFile: SourceFile, search: Search, state: State): void {
+        if (getNameTable(sourceFile).get(search.escapedText) !== undefined) {
+            getReferencesInSourceFile(sourceFile, search, state);
+        }
+    }
+
+    function getPropertySymbolOfDestructuringAssignment(location: Node, checker: TypeChecker): Symbol | undefined {
         return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) &&
-            typeChecker.getPropertySymbolOfDestructuringAssignment(<Identifier>location);
+            checker.getPropertySymbolOfDestructuringAssignment(<Identifier>location);
     }
 
-    function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol) {
+    function isObjectBindingPatternElementWithoutPropertyName(symbol: Symbol): boolean {
         const bindingElement = <BindingElement>getDeclarationOfKind(symbol, SyntaxKind.BindingElement);
         return bindingElement &&
             bindingElement.parent.kind === SyntaxKind.ObjectBindingPattern &&
             !bindingElement.propertyName;
     }
 
-    function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol, typeChecker: TypeChecker) {
+    function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol: Symbol, checker: TypeChecker): Symbol | undefined {
         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);
+            const typeOfPattern = checker.getTypeAtLocation(bindingElement.parent);
+            return typeOfPattern && checker.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.text;
-        }
-
-        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
@@ -305,71 +582,71 @@ namespace ts.FindAllReferences {
      * @returns undefined if the scope cannot be determined, implying that
      * a reference to a symbol can occur anywhere.
      */
-    function getSymbolScope(symbol: Symbol): Node {
+    function getSymbolScope(symbol: Symbol): Node | undefined {
         // 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;
+        const { declarations, flags, parent, valueDeclaration } = symbol;
         if (valueDeclaration && (valueDeclaration.kind === SyntaxKind.FunctionExpression || valueDeclaration.kind === SyntaxKind.ClassExpression)) {
             return valueDeclaration;
         }
 
+        if (!declarations) {
+            return undefined;
+        }
+
         // 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 (flags & (SymbolFlags.Property | SymbolFlags.Method)) {
+            const privateDeclaration = find(declarations, d => !!(getModifierFlags(d) & ModifierFlags.Private));
             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.Transient && (<TransientSymbol>symbol).checkFlags & CheckFlags.Synthetic)) {
+        // If the symbol has a parent, it's globally visible.
+        // Unless that parent is an external module, then we should only search in the module (and recurse on the export later).
+        // But if the parent is a module that has `export as namespace`, then the symbol *is* globally visible.
+        if (parent && !((parent.flags & SymbolFlags.Module) && isExternalModuleSymbol(parent) && !parent.globalExports)) {
             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;
-            }
+        // If this is a synthetic property, it's a property and must be searched for globally.
+        if ((flags & SymbolFlags.Transient && (<TransientSymbol>symbol).checkFlags & CheckFlags.Synthetic)) {
+            return undefined;
         }
 
-        return scope;
+        let scope: Node | undefined;
+        for (const declaration of declarations) {
+            const container = getContainerNode(declaration);
+            if (scope && scope !== container) {
+                // Different declarations have different containers, bail out
+                return undefined;
+            }
+
+            if (!container || container.kind === SyntaxKind.SourceFile && !isExternalOrCommonJsModule(<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;
+        }
+
+        // If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.)
+        // For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.:
+        //     declare module "a" { export type T = number; }
+        //     declare module "b" { import { T } from "a"; export const x: T; }
+        // So we must search the whole source file. (Because we will mark the source file as seen, we we won't return to it when searching for imports.)
+        return parent ? scope.getSourceFile() : scope;
     }
 
-    function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number, cancellationToken: CancellationToken): number[] {
+    function getPossibleSymbolReferencePositions(sourceFile: SourceFile, symbolName: string, start: number, end: number): number[] {
         const positions: number[] = [];
 
         /// TODO: Cache symbol existence for files to save text search
@@ -386,8 +663,6 @@ namespace ts.FindAllReferences {
 
         let position = text.indexOf(symbolName, start);
         while (position >= 0) {
-            cancellationToken.throwIfCancellationRequested();
-
             // If we are past the end, stop looking
             if (position > end) break;
 
@@ -406,38 +681,25 @@ namespace ts.FindAllReferences {
         return positions;
     }
 
-    function getLabelReferencesInNode<T extends DocumentSpan>(container: Node, targetLabel: Identifier, context: FindReferencesContext<T>): ReferencedSymbolOf<T>[] {
-        const references: T[] = [];
+    function getLabelReferencesInNode(container: Node, targetLabel: Identifier): SymbolAndEntries[] {
+        const references: Entry[] = [];
         const sourceFile = container.getSourceFile();
         const labelName = targetLabel.text;
-        const { cancellationToken } = context;
-        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd(), cancellationToken);
-        forEach(possiblePositions, position => {
-            cancellationToken.throwIfCancellationRequested();
-
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd());
+        for (const position of possiblePositions) {
             const node = getTouchingWord(sourceFile, position);
             if (!node || node.getWidth() !== labelName.length) {
-                return;
+                continue;
             }
 
             // 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(context.getReferenceEntryFromNode(node));
+                references.push(nodeEntry(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 }];
+        return [{ definition: { type: "label", node: targetLabel }, references }];
     }
 
     function isValidReferencePosition(node: Node, searchSymbolName: string): boolean {
@@ -459,192 +721,225 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function getAllReferencesForKeyword<T extends DocumentSpan>(context: FindReferencesContext<T>, sourceFiles: SourceFile[], keywordKind: ts.SyntaxKind): ReferencedSymbolOf<T>[] {
-        const { cancellationToken } = context;
-        const name = tokenToString(keywordKind);
-        const references: T[] = [];
+    function getAllReferencesForKeyword(sourceFiles: SourceFile[], keywordKind: ts.SyntaxKind, cancellationToken: CancellationToken): SymbolAndEntries[] {
+        const references: NodeEntry[] = [];
         for (const sourceFile of sourceFiles) {
             cancellationToken.throwIfCancellationRequested();
-            addReferencesForKeywordInFile(sourceFile, keywordKind, name, context, references);
+            addReferencesForKeywordInFile(sourceFile, keywordKind, tokenToString(keywordKind), references);
         }
-
-        if (!references.length) return undefined;
-
-        const definition: ReferencedSymbolDefinitionInfo = {
-            containerKind: "",
-            containerName: "",
-            fileName: references[0].fileName,
-            kind: ScriptElementKind.keyword,
-            name,
-            textSpan: references[0].textSpan,
-            displayParts: [{ text: name, kind: ScriptElementKind.keyword }]
-        };
-
-        return [{ definition, references }];
+        return references.length ? [{ definition: { type: "keyword", node: references[0].node }, references }] : undefined;
     }
 
-    function addReferencesForKeywordInFile<T extends DocumentSpan>(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, context: FindReferencesContext<T>, references: Push<T>): void {
-        const { cancellationToken } = context;
-        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
+    function addReferencesForKeywordInFile(sourceFile: SourceFile, kind: SyntaxKind, searchText: string, references: Push<NodeEntry>): void {
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, sourceFile.getStart(), sourceFile.getEnd());
         for (const position of possiblePositions) {
-            cancellationToken.throwIfCancellationRequested();
             const referenceLocation = getTouchingPropertyName(sourceFile, position);
             if (referenceLocation.kind === kind) {
-                references.push(context.getReferenceEntryForSpanInFile(sourceFile.fileName, createTextSpanFromNode(referenceLocation)));
+                references.push(nodeEntry(referenceLocation));
             }
         }
     }
 
-    /** Search within node "container" for references for a search value, where the search value is defined as a
+    function getReferencesInSourceFile(sourceFile: ts.SourceFile, search: Search, state: State): void {
+        state.cancellationToken.throwIfCancellationRequested();
+        return getReferencesInContainer(sourceFile, sourceFile, search, state);
+    }
+
+    /**
+     * 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<T extends DocumentSpan>(container: Node,
-        searchSymbol: Symbol,
-        searchText: string,
-        searchLocation: Node,
-        searchMeaning: SemanticMeaning,
-        findInStrings: boolean,
-        findInComments: boolean,
-        result: ReferencedSymbolOf<T>[],
-        symbolToIndex: number[],
-        implementations: boolean,
-        context: FindReferencesContext<T>,
-        searchSymbols: Symbol[],
-        inheritsFromCache: Map<boolean>): void {
-
-        const sourceFile = container.getSourceFile();
-        const { typeChecker, cancellationToken } = context;
-
-        const start = findInComments ? container.getFullStart() : container.getStart();
-        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, searchText, start, container.getEnd(), cancellationToken);
-
-        const parents = getParentSymbolsOfPropertyAccess();
+    function getReferencesInContainer(container: Node, sourceFile: ts.SourceFile, search: Search, state: State): void {
+        if (!state.markSearchedSymbol(sourceFile, search.symbol)) {
+            return;
+        }
 
+        const start = state.findInComments ? container.getFullStart() : container.getStart();
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, search.text, start, container.getEnd());
         for (const position of possiblePositions) {
-            cancellationToken.throwIfCancellationRequested();
+            getReferencesAtLocation(sourceFile, position, search, state);
+        }
+    }
 
-            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)))) {
+    function getReferencesAtLocation(sourceFile: SourceFile, position: number, search: Search, state: State): void {
+        const referenceLocation = getTouchingPropertyName(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: [context.getReferenceEntryForSpanInFile(sourceFile.fileName, createTextSpan(position, searchText.length))]
-                    });
-                }
-                continue;
+        if (!isValidReferencePosition(referenceLocation, search.text)) {
+            // 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 (!state.implementations && (state.findInStrings && isInString(sourceFile, position) || state.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.
+                state.addStringOrCommentReference(sourceFile.fileName, createTextSpan(position, search.text.length));
             }
 
-            if (!(getMeaningFromLocation(referenceLocation) & searchMeaning)) {
-                continue;
+            return;
+        }
+
+        if (!(getMeaningFromLocation(referenceLocation) & state.searchMeaning)) {
+            return;
+        }
+
+        const referenceSymbol = state.checker.getSymbolAtLocation(referenceLocation);
+        if (!referenceSymbol) {
+            return;
+        }
+
+        const { parent } = referenceLocation;
+        if (isImportSpecifier(parent) && parent.propertyName === referenceLocation) {
+            // This is added through `singleReferences` in ImportsResult. If we happen to see it again, don't add it again.
+            return;
+        }
+
+        if (isExportSpecifier(parent)) {
+            Debug.assert(referenceLocation.kind === SyntaxKind.Identifier);
+            getReferencesAtExportSpecifier(referenceLocation as Identifier, referenceSymbol, parent, search, state);
+            return;
+        }
+
+        const relatedSymbol = getRelatedSymbol(search, referenceSymbol, referenceLocation, state);
+        if (!relatedSymbol) {
+            getReferenceForShorthandProperty(referenceSymbol, search, state);
+            return;
+        }
+
+        if (state.isForConstructor) {
+            findConstructorReferences(referenceLocation, sourceFile, search, state);
+        }
+        else {
+            addReference(referenceLocation, relatedSymbol, search.location, state);
+        }
+
+        getImportOrExportReferences(referenceLocation, referenceSymbol, search, state);
+    }
+
+    function getReferencesAtExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, search: Search, state: State): void {
+        const { parent, propertyName, name } = exportSpecifier;
+        const exportDeclaration = parent.parent;
+        const localSymbol = getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker);
+        if (!search.includes(localSymbol)) {
+            return;
+        }
+
+        if (!propertyName) {
+            addRef();
+        }
+        else if (referenceLocation === propertyName) {
+            // For `export { foo as bar } from "baz"`, "`foo`" will be added from the singleReferences for import searches of the original export.
+            // For `export { foo as bar };`, where `foo` is a local, so add it now.
+            if (!exportDeclaration.moduleSpecifier) {
+                addRef();
             }
 
-            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 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) && contains(searchSymbols, shorthandValueSymbol)) {
-                    addReferenceToRelatedSymbol(referenceSymbolDeclaration.name, shorthandValueSymbol);
-                }
-                else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
-                    findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
-                }
+            if (!state.isForRename && state.markSeenReExportRHS(name)) {
+                addReference(name, referenceSymbol, name, state);
+            }
+        }
+        else {
+            if (state.markSeenReExportRHS(referenceLocation)) {
+                addRef();
             }
         }
-        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)
+        // For `export { foo as bar }`, rename `foo`, but not `bar`.
+        if (!(referenceLocation === propertyName && state.isForRename)) {
+            const exportKind = (referenceLocation as Identifier).originalKeywordKind === ts.SyntaxKind.DefaultKeyword ? ExportKind.Default : ExportKind.Named;
+            const exportInfo = getExportInfo(referenceSymbol, exportKind, state.checker);
+            Debug.assert(!!exportInfo);
+            searchForImportsOfExport(referenceLocation, referenceSymbol, exportInfo, state);
+        }
+
+        // At `export { x } from "foo"`, also search for the imported symbol `"foo".x`.
+        if (search.comingFrom !== ImportExport.Export && exportDeclaration.moduleSpecifier && !propertyName) {
+            searchForImportedSymbol(state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier), state);
+        }
+
+        function addRef() {
+            addReference(referenceLocation, localSymbol, search.location, state);
+        }
+    }
+
+    function getLocalSymbolForExportSpecifier(referenceLocation: Identifier, referenceSymbol: Symbol, exportSpecifier: ExportSpecifier, checker: TypeChecker): Symbol {
+        return isExportSpecifierAlias(referenceLocation, exportSpecifier) ? checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) : referenceSymbol;
+    }
+
+    function isExportSpecifierAlias(referenceLocation: Identifier, exportSpecifier: ExportSpecifier): boolean {
+        const { parent, propertyName, name } = exportSpecifier;
+        Debug.assert(propertyName === referenceLocation || name === referenceLocation);
+        if (propertyName) {
+            // Given `export { foo as bar } [from "someModule"]`: It's an alias at `foo`, but at `bar` it's a new symbol.
+            return propertyName === referenceLocation;
+        }
+        else {
+            // `export { foo } from "foo"` is a re-export.
+            // `export { foo };` is not a re-export, it creates an alias for the local variable `foo`.
+            return !parent.parent.moduleSpecifier;
+        }
+    }
+
+    function getImportOrExportReferences(referenceLocation: Node, referenceSymbol: Symbol, search: Search, state: State): void {
+        const importOrExport = getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom === ImportExport.Export);
+        if (!importOrExport) return;
+
+        const { symbol } = importOrExport;
+
+        if (importOrExport.kind === ImportExport.Import) {
+            if (!state.isForRename || importOrExport.isNamedImport) {
+                searchForImportedSymbol(symbol, state);
+            }
+        }
+        else {
+            // We don't check for `state.isForRename`, even for default exports, because importers that previously matched the export name should be updated to continue matching.
+            searchForImportsOfExport(referenceLocation, symbol, importOrExport.exportInfo, state);
+        }
+    }
+
+    function getReferenceForShorthandProperty({ flags, valueDeclaration }: Symbol, search: Search, state: State): void {
+        const shorthandValueSymbol = state.checker.getShorthandAssignmentValueSymbol(valueDeclaration);
+        /*
+         * Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
+         * 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.
          */
-        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);
-                        }
-                    }
-                }
-            }
+        if (!(flags & SymbolFlags.Transient) && search.includes(shorthandValueSymbol)) {
+            addReference(valueDeclaration.name, shorthandValueSymbol, search.location, state);
+        }
+    }
+
+    function addReference(referenceLocation: Node, relatedSymbol: Symbol, searchLocation: Node, state: State): void {
+        const addRef = state.referenceAdder(relatedSymbol, searchLocation);
+        if (state.implementations) {
+            addImplementationReferences(referenceLocation, addRef, state);
+        }
+        else {
+            addRef(referenceLocation);
+        }
+    }
+
+    /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses.  */
+    function findConstructorReferences(referenceLocation: Node, sourceFile: SourceFile, search: Search, state: State): void {
+        if (isNewExpressionTarget(referenceLocation)) {
+            addReference(referenceLocation, search.symbol, search.location, state);
         }
 
-        /** 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 pusher = state.referenceAdder(search.symbol, search.location);
 
-            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, sourceFile));
-            }
-            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));
-                }
-            }
+        if (isClassLike(referenceLocation.parent)) {
+            Debug.assert(referenceLocation.parent.name === referenceLocation);
+            // This is the class declaration containing the constructor.
+            findOwnConstructorReferences(search.symbol, sourceFile, pusher);
         }
-
-        function addReferences(references: Node[]): void {
-            if (references.length) {
-                const referencedSymbol = getReferencedSymbol(searchSymbol);
-                addRange(referencedSymbol.references, map(references, n => context.getReferenceEntryFromNode(n)));
-            }
-        }
-
-        function getReferencedSymbol(symbol: Symbol): ReferencedSymbolOf<T> {
-            const symbolId = getSymbolId(symbol);
-            let index = symbolToIndex[symbolId];
-            if (index === undefined) {
-                index = result.length;
-                symbolToIndex[symbolId] = index;
-
-                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, context);
-            }
-            else {
-                references.push(context.getReferenceEntryFromNode(node));
+        else {
+            // If this class appears in `extends C`, then the extending class' "super" calls are references.
+            const classExtending = tryGetClassByExtendingIdentifier(referenceLocation);
+            if (classExtending && isClassLike(classExtending)) {
+                findSuperConstructorAccesses(classExtending, pusher);
             }
         }
     }
@@ -653,16 +948,15 @@ namespace ts.FindAllReferences {
         return isRightSideOfPropertyAccess(node) && <PropertyAccessExpression>node.parent;
     }
 
-    /** `classSymbol` is the class where the constructor was defined.
+    /**
+     * `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[] = [];
-
+    function findOwnConstructorReferences(classSymbol: Symbol, sourceFile: SourceFile, addNode: (node: Node) => void): void {
         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);
+            addNode(ctrKeyword);
         }
 
         classSymbol.exports.forEach(member => {
@@ -672,90 +966,79 @@ namespace ts.FindAllReferences {
                 if (body) {
                     forEachDescendantOfKind(body, SyntaxKind.ThisKeyword, thisKeyword => {
                         if (isNewExpressionTarget(thisKeyword)) {
-                            result.push(thisKeyword);
+                            addNode(thisKeyword);
                         }
                     });
                 }
             }
         });
-
-        return result;
     }
 
     /** Find references to `super` in the constructor of an extending class.  */
-    function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
+    function findSuperConstructorAccesses(cls: ClassLikeDeclaration, addNode: (node: Node) => void): void {
         const symbol = cls.symbol;
         const ctr = symbol.members.get("__constructor");
         if (!ctr) {
-            return [];
+            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);
+                        addNode(node);
                     }
                 });
             }
         }
-        return result;
     }
 
-    function getImplementationReferenceEntryForNode<T extends DocumentSpan>(refNode: Node, result: T[], context: FindReferencesContext<T>): void {
+    function addImplementationReferences(refNode: Node, addReference: (node: Node) => void, state: State): void {
         // Check if we found a function/propertyAssignment/method with an implementation or initializer
         if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
-            result.push(context.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, context, result);
-            }
-
-            // Check if the node is within an extends or implements clause
-            const containingClass = getContainingClassIfInHeritageClause(refNode);
-            if (containingClass) {
-                result.push(context.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(context.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(context.getReferenceEntryFromNode(returnStatement.expression));
-                            }
-                        });
-                    }
-                    else if (isImplementationExpression(<Expression>parent.body)) {
-                        maybeAdd(context.getReferenceEntryFromNode(parent.body));
-                    }
-                }
-                else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) {
-                    maybeAdd(context.getReferenceEntryFromNode(parent.expression));
-                }
-            }
+            addReference(refNode.parent);
+            return;
         }
 
-        // 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: T) {
-            if (!forEach(result, b => a.fileName === b.fileName && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length)) {
-                result.push(a);
+        if (refNode.kind !== SyntaxKind.Identifier) {
+            return;
+        }
+
+        if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            // Go ahead and dereference the shorthand assignment by going to its definition
+            getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference);
+        }
+
+        // Check if the node is within an extends or implements clause
+        const containingClass = getContainingClassIfInHeritageClause(refNode);
+        if (containingClass) {
+            addReference(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 && state.markSeenContainingTypeReference(containingTypeReference)) {
+            const parent = containingTypeReference.parent;
+            if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {
+                addReference(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)) {
+                            addReference(returnStatement.expression);
+                        }
+                    });
+                }
+                else if (isImplementationExpression(<Expression>parent.body)) {
+                    addReference(parent.body);
+                }
+            }
+            else if (isAssertionExpression(parent) && isImplementationExpression(parent.expression)) {
+                addReference(parent.expression);
             }
         }
     }
@@ -837,7 +1120,7 @@ namespace ts.FindAllReferences {
      * @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 {
+    function explicitlyInheritsFrom(child: Symbol, parent: Symbol, cachedResults: Map<boolean>, checker: TypeChecker): boolean {
         const parentIsInterface = parent.getFlags() & SymbolFlags.Interface;
         return searchHierarchy(child);
 
@@ -883,7 +1166,7 @@ namespace ts.FindAllReferences {
 
         function searchTypeReference(typeReference: ExpressionWithTypeArguments): boolean {
             if (typeReference) {
-                const type = typeChecker.getTypeAtLocation(typeReference);
+                const type = checker.getTypeAtLocation(typeReference);
                 if (type && type.symbol) {
                     return searchHierarchy(type.symbol);
                 }
@@ -892,7 +1175,7 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function getReferencesForSuperKeyword<T extends DocumentSpan>(superKeyword: Node, context: FindReferencesContext<T>): ReferencedSymbolOf<T>[] {
+    function getReferencesForSuperKeyword(superKeyword: Node): SymbolAndEntries[] {
         let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false);
         if (!searchSpaceNode) {
             return undefined;
@@ -915,14 +1198,11 @@ namespace ts.FindAllReferences {
                 return undefined;
         }
 
-        const references: T[] = [];
-        const { typeChecker, cancellationToken } = context;
+        const references: Entry[] = [];
 
         const sourceFile = searchSpaceNode.getSourceFile();
-        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd(), cancellationToken);
+        const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd());
         for (const position of possiblePositions) {
-            cancellationToken.throwIfCancellationRequested();
-
             const node = getTouchingWord(sourceFile, position);
 
             if (!node || node.kind !== SyntaxKind.SuperKeyword) {
@@ -935,17 +1215,15 @@ namespace ts.FindAllReferences {
             // 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(context.getReferenceEntryFromNode(node));
+                references.push(nodeEntry(node));
             }
         }
 
-        const definition = getDefinition(searchSpaceNode.symbol, superKeyword, typeChecker);
-        return [{ definition, references }];
+        return [{ definition: { type: "symbol", symbol: searchSpaceNode.symbol, node: superKeyword }, references }];
     }
 
-    function getReferencesForThisKeyword<T extends DocumentSpan>(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], context: FindReferencesContext<T>): ReferencedSymbolOf<T>[] {
+    function getReferencesForThisKeyword(thisOrSuperKeyword: Node, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] {
         let searchSpaceNode = getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
-        const { typeChecker, cancellationToken } = context;
 
         // Whether 'this' occurs in a static context within a class.
         let staticFlag = ModifierFlags.Static;
@@ -979,43 +1257,29 @@ namespace ts.FindAllReferences {
                 return undefined;
         }
 
-        const references: T[] = [];
+        const references: Entry[] = [];
 
         let possiblePositions: number[];
         if (searchSpaceNode.kind === SyntaxKind.SourceFile) {
             forEach(sourceFiles, sourceFile => {
-                possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
+                cancellationToken.throwIfCancellationRequested();
+                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(), cancellationToken);
+            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: thisOrSuperKeyword.getSourceFile().fileName,
-                kind: ScriptElementKind.variableElement,
-                name: "this",
-                textSpan: createTextSpanFromNode(thisOrSuperKeyword),
-                displayParts
-            },
-            references: references
+            definition: { type: "this", node: thisOrSuperKeyword },
+            references
         }];
 
-        function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: T[]): void {
+        function getThisReferencesInFile(sourceFile: SourceFile, searchSpaceNode: Node, possiblePositions: number[], result: Entry[]): void {
             forEach(possiblePositions, position => {
-                cancellationToken.throwIfCancellationRequested();
-
                 const node = getTouchingWord(sourceFile, position);
                 if (!node || !isThis(node)) {
                     return;
@@ -1027,13 +1291,13 @@ namespace ts.FindAllReferences {
                     case SyntaxKind.FunctionExpression:
                     case SyntaxKind.FunctionDeclaration:
                         if (searchSpaceNode.symbol === container.symbol) {
-                            result.push(context.getReferenceEntryFromNode(node));
+                            result.push(nodeEntry(node));
                         }
                         break;
                     case SyntaxKind.MethodDeclaration:
                     case SyntaxKind.MethodSignature:
                         if (isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) {
-                            result.push(context.getReferenceEntryFromNode(node));
+                            result.push(nodeEntry(node));
                         }
                         break;
                     case SyntaxKind.ClassExpression:
@@ -1041,12 +1305,12 @@ namespace ts.FindAllReferences {
                         // 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(context.getReferenceEntryFromNode(node));
+                            result.push(nodeEntry(node));
                         }
                         break;
                     case SyntaxKind.SourceFile:
                         if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
-                            result.push(context.getReferenceEntryFromNode(node));
+                            result.push(nodeEntry(node));
                         }
                         break;
                 }
@@ -1054,87 +1318,67 @@ namespace ts.FindAllReferences {
         }
     }
 
-    function getReferencesForStringLiteral<T extends DocumentSpan>(node: StringLiteral, sourceFiles: SourceFile[], context: FindReferencesContext<T>): ReferencedSymbolOf<T>[] {
-        const { typeChecker, cancellationToken } = context;
-        const type = getStringLiteralTypeForNode(node, typeChecker);
-
-        if (!type) {
-            // nothing to do here. moving on
-            return undefined;
-        }
-
-        const references: T[] = [];
+    function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] {
+        const references: NodeEntry[] = [];
 
         for (const sourceFile of sourceFiles) {
-            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, type.text, sourceFile.getStart(), sourceFile.getEnd(), cancellationToken);
-            getReferencesForStringLiteralInFile(sourceFile, type, possiblePositions, references);
+            cancellationToken.throwIfCancellationRequested();
+            const possiblePositions = getPossibleSymbolReferencePositions(sourceFile, node.text, sourceFile.getStart(), sourceFile.getEnd());
+            getReferencesForStringLiteralInFile(sourceFile, node.text, 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
+            definition: { type: "string", node },
+            references
         }];
 
-        function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchType: Type, possiblePositions: number[], references: T[]): void {
+        function getReferencesForStringLiteralInFile(sourceFile: SourceFile, searchText: string, possiblePositions: number[], references: Push<NodeEntry>): 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(context.getReferenceEntryFromNode(node, /*isInString*/ true));
+                if (node && node.kind === SyntaxKind.StringLiteral && (node as StringLiteral).text === searchText) {
+                    references.push(nodeEntry(node, /*isInString*/ true));
                 }
             }
         }
     }
 
-    function populateSearchSymbolSet(symbol: Symbol, location: Node, typeChecker: TypeChecker, implementations: boolean): Symbol[] {
+    // For certain symbol kinds, we need to include other symbols in the search set.
+    // This is not needed when searching for re-exports.
+    function populateSearchSymbolSet(symbol: Symbol, location: Node, checker: TypeChecker, implementations: boolean): Symbol[] {
         // The search set contains at least the current symbol
         const 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 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));
+            // If the location is name of property symbol from object literal destructuring pattern
+            // Search the property symbol
+            //      for ( { property: p2 } of elems) { }
+            if (containingObjectLiteralElement.kind !== SyntaxKind.ShorthandPropertyAssignment) {
+                const propertySymbol = getPropertySymbolOfDestructuringAssignment(location, checker);
+                if (propertySymbol) {
+                    result.push(propertySymbol);
+                }
+            }
+
+            // 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
+            forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, checker), contextualSymbol => {
+                addRange(result, checker.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);
+             * 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 = checker.getShorthandAssignmentValueSymbol(location.parent);
             if (shorthandValueSymbol) {
                 result.push(shorthandValueSymbol);
             }
@@ -1146,26 +1390,26 @@ 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)) {
-            addRange(result, typeChecker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
+            addRange(result, checker.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);
+        const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker);
         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
-        for (const rootSymbol of typeChecker.getRootSymbols(symbol)) {
+        for (const rootSymbol of checker.getRootSymbols(symbol)) {
             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);
+                getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), checker);
             }
         }
 
@@ -1180,8 +1424,7 @@ namespace ts.FindAllReferences {
      * @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 {
+    function getPropertySymbolsFromBaseTypes(symbol: Symbol, propertyName: string, result: Symbol[], previousIterationSymbolsCache: SymbolTable, checker: TypeChecker): void {
         if (!symbol) {
             return;
         }
@@ -1214,34 +1457,26 @@ namespace ts.FindAllReferences {
         }
         return;
 
-        function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments) {
+        function getPropertySymbolFromTypeReference(typeReference: ExpressionWithTypeArguments): void {
             if (typeReference) {
-                const type = typeChecker.getTypeAtLocation(typeReference);
+                const type = checker.getTypeAtLocation(typeReference);
                 if (type) {
-                    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+                    const propertySymbol = checker.getPropertyOfType(type, propertyName);
                     if (propertySymbol) {
-                        result.push(...typeChecker.getRootSymbols(propertySymbol));
+                        result.push(...checker.getRootSymbols(propertySymbol));
                     }
 
                     // Visit the typeReference as well to see if it directly or indirectly use that property
                     previousIterationSymbolsCache.set(symbol.name, symbol);
-                    getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, typeChecker);
+                    getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, checker);
                 }
             }
         }
     }
 
-    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;
-        }
-
-        // 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);
+    function getRelatedSymbol(search: Search, referenceSymbol: Symbol, referenceLocation: Node, state: State): Symbol | undefined {
+        if (search.includes(referenceSymbol)) {
+            return referenceSymbol;
         }
 
         // If the reference location is in an object literal, try to get the contextual type for the
@@ -1249,8 +1484,8 @@ namespace ts.FindAllReferences {
         // compare to our searchSymbol
         const containingObjectLiteralElement = getContainingObjectLiteralElement(referenceLocation);
         if (containingObjectLiteralElement) {
-            const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, typeChecker), contextualSymbol =>
-                find(typeChecker.getRootSymbols(contextualSymbol), symbol => contains(searchSymbols, symbol)));
+            const contextualSymbol = forEach(getPropertySymbolsFromContextualType(containingObjectLiteralElement, state.checker), contextualSymbol =>
+                find(state.checker.getRootSymbols(contextualSymbol), search.includes));
 
             if (contextualSymbol) {
                 return contextualSymbol;
@@ -1260,8 +1495,8 @@ namespace ts.FindAllReferences {
             // 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 && contains(searchSymbols, propertySymbol)) {
+            const propertySymbol = getPropertySymbolOfDestructuringAssignment(referenceLocation, state.checker);
+            if (propertySymbol && search.includes(propertySymbol)) {
                 return propertySymbol;
             }
         }
@@ -1269,16 +1504,16 @@ namespace ts.FindAllReferences {
         // 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 && contains(searchSymbols, bindingElementPropertySymbol)) {
+        const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(referenceSymbol, state.checker);
+        if (bindingElementPropertySymbol && search.includes(bindingElementPropertySymbol)) {
             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 => {
+        return forEach(state.checker.getRootSymbols(referenceSymbol), rootSymbol => {
             // if it is in the list, then we are done
-            if (contains(searchSymbols, rootSymbol)) {
+            if (search.includes(rootSymbol)) {
                 return rootSymbol;
             }
 
@@ -1287,22 +1522,20 @@ namespace ts.FindAllReferences {
             // 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;
-                    }
+                if (search.parents && !some(search.parents, parent => explicitlyInheritsFrom(rootSymbol.parent, parent, state.inheritsFromCache, state.checker))) {
+                    return undefined;
                 }
 
                 const result: Symbol[] = [];
-                getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), typeChecker);
-                return find(result, symbol => contains(searchSymbols, symbol));
+                getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>(), state.checker);
+                return find(result, search.includes);
             }
 
             return undefined;
         });
     }
 
-    function getNameFromObjectLiteralElement(node: ObjectLiteralElement) {
+    function getNameFromObjectLiteralElement(node: ObjectLiteralElement): string {
         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
@@ -1315,9 +1548,9 @@ namespace ts.FindAllReferences {
     }
 
     /** Gets all symbols for one property. Does not get symbols for every property. */
-    function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, typeChecker: TypeChecker): Symbol[] | undefined {
+    function getPropertySymbolsFromContextualType(node: ObjectLiteralElement, checker: TypeChecker): Symbol[] | undefined {
         const objectLiteral = <ObjectLiteralExpression>node.parent;
-        const contextualType = typeChecker.getContextualType(objectLiteral);
+        const contextualType = checker.getContextualType(objectLiteral);
         const name = getNameFromObjectLiteralElement(node);
         if (name && contextualType) {
             const result: Symbol[] = [];
@@ -1407,58 +1640,20 @@ namespace ts.FindAllReferences {
         }
     }
 
-    export function getReferenceEntriesForShorthandPropertyAssignment<T extends DocumentSpan>(node: Node, context: FindReferencesContext<T>, result: T[]): void {
-        const { typeChecker } = context;
-        const refSymbol = typeChecker.getSymbolAtLocation(node);
-        const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration);
+    export function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void {
+        const refSymbol = checker.getSymbolAtLocation(node);
+        const shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration);
 
         if (shorthandSymbol) {
             for (const declaration of shorthandSymbol.getDeclarations()) {
                 if (getMeaningFromDeclaration(declaration) & SemanticMeaning.Value) {
-                    result.push(context.getReferenceEntryFromNode(declaration));
+                    addReference(declaration);
                 }
             }
         }
     }
 
-    export function getReferenceEntryFromNode(node: Node): ReferenceEntry {
-        let start = node.getStart();
-        let end = node.getEnd();
-
-        if (node.kind === SyntaxKind.StringLiteral) {
-            start += 1;
-            end -= 1;
-        }
-
-        return {
-            fileName: node.getSourceFile().fileName,
-            textSpan: createTextSpanFromBounds(start, end),
-            isWriteAccess: isWriteAccess(node),
-            isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node)
-        };
-    }
-
-    /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */
-    function isWriteAccess(node: Node): boolean {
-        if (node.kind === SyntaxKind.Identifier && isDeclarationName(node)) {
-            return true;
-        }
-
-        const parent = node.parent;
-        if (parent) {
-            if (parent.kind === SyntaxKind.PostfixUnaryExpression || parent.kind === SyntaxKind.PrefixUnaryExpression) {
-                return true;
-            }
-            else if (parent.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>parent).left === node) {
-                const operator = (<BinaryExpression>parent).operatorToken.kind;
-                return SyntaxKind.FirstAssignment <= operator && operator <= SyntaxKind.LastAssignment;
-            }
-        }
-
-        return false;
-    }
-
-    function forEachDescendantOfKind(node: Node, kind: SyntaxKind, action: (node: Node) => void) {
+    function forEachDescendantOfKind(node: Node, kind: SyntaxKind, action: (node: Node) => void): void {
         forEachChild(node, child => {
             if (child.kind === kind) {
                 action(child);
@@ -1480,7 +1675,28 @@ namespace ts.FindAllReferences {
         return false;
     }
 
-    function isImportDefaultSymbol(symbol: Symbol): boolean {
-        return symbol.declarations[0].kind === SyntaxKind.ImportClause;
+    /**
+     * 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(location: Node, symbol: Symbol, checker: TypeChecker): Symbol[] | undefined {
+        const propertyAccessExpression = getPropertyAccessExpressionFromRightHandSide(location);
+        if (!propertyAccessExpression) {
+            return undefined;
+        }
+
+        const localParentType = checker.getTypeAtLocation(propertyAccessExpression.expression);
+        if (!localParentType) {
+            return undefined;
+        }
+
+        if (localParentType.symbol && localParentType.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) && localParentType.symbol !== symbol.parent) {
+            return [localParentType.symbol];
+        }
+        else if (localParentType.flags & TypeFlags.UnionOrIntersection) {
+            return getSymbolsForClassAndInterfaceComponents(<UnionOrIntersectionType>localParentType);
+        }
     }
 }
diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts
new file mode 100644
index 00000000000..1d1f9d881e1
--- /dev/null
+++ b/src/services/importTracker.ts
@@ -0,0 +1,567 @@
+/* Code for finding imports of an exported symbol. Used only by FindAllReferences. */
+/* @internal */
+namespace ts.FindAllReferences {
+    export interface ImportsResult {
+        /** For every import of the symbol, the location and local symbol for the import. */
+        importSearches: Array<[Identifier, Symbol]>;
+        /** For rename imports/exports `{ foo as bar }`, `foo` is not a local, so it may be added as a reference immediately without further searching. */
+        singleReferences: Identifier[];
+        /** List of source files that may (or may not) use the symbol via a namespace. (For UMD modules this is every file.) */
+        indirectUsers: SourceFile[];
+    }
+    export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult;
+
+    /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.  */
+    export function createImportTracker(sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): ImportTracker {
+        const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken);
+        return (exportSymbol, exportInfo, isForRename) => {
+            const { directImports, indirectUsers } = getImportersForExport(sourceFiles, allDirectImports, exportInfo, checker, cancellationToken);
+            return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) };
+        };
+    }
+
+    /** Info about an exported symbol to perform recursive search on. */
+    export interface ExportInfo {
+        exportingModuleSymbol: Symbol;
+        exportKind: ExportKind;
+    }
+
+    export const enum ExportKind { Named, Default, ExportEquals }
+
+    export const enum ImportExport { Import, Export }
+
+    interface AmbientModuleDeclaration extends ModuleDeclaration { body?: ModuleBlock; }
+    type SourceFileLike = SourceFile | AmbientModuleDeclaration;
+    // Identifier for the case of `const x = require("y")`.
+    type Importer = AnyImportSyntax | Identifier | ExportDeclaration;
+    type ImporterOrCallExpression = Importer | CallExpression;
+
+    /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */
+    function getImportersForExport(
+            sourceFiles: SourceFile[],
+            allDirectImports: Map<ImporterOrCallExpression[]>,
+            { exportingModuleSymbol, exportKind }: ExportInfo,
+            checker: TypeChecker,
+            cancellationToken: CancellationToken
+            ): { directImports: Importer[], indirectUsers: SourceFile[] } {
+        const markSeenDirectImport = nodeSeenTracker<ImporterOrCallExpression>();
+        const markSeenIndirectUser = nodeSeenTracker<SourceFileLike>();
+        const directImports: Importer[] = [];
+        const isAvailableThroughGlobal = !!exportingModuleSymbol.globalExports;
+        const indirectUserDeclarations: SourceFileLike[] = isAvailableThroughGlobal ? undefined : [];
+
+        handleDirectImports(exportingModuleSymbol);
+
+        return { directImports, indirectUsers: getIndirectUsers() };
+
+        function getIndirectUsers(): SourceFile[] {
+            if (isAvailableThroughGlobal) {
+                // It has `export as namespace`, so anything could potentially use it.
+                return sourceFiles;
+            }
+
+            // Module augmentations may use this module's exports without importing it.
+            for (const decl of exportingModuleSymbol.declarations) {
+                if (isExternalModuleAugmentation(decl)) {
+                    addIndirectUser(decl as SourceFileLike);
+                }
+            }
+
+            // This may return duplicates (if there are multiple module declarations in a single source file, all importing the same thing as a namespace), but `State.markSearchedSymbol` will handle that.
+            return indirectUserDeclarations.map(getSourceFileOfNode);
+        }
+
+        function handleDirectImports(exportingModuleSymbol: Symbol): void {
+            const theseDirectImports = getDirectImports(exportingModuleSymbol);
+            if (theseDirectImports) for (const direct of theseDirectImports) {
+                if (!markSeenDirectImport(direct)) {
+                    continue;
+                }
+
+                cancellationToken.throwIfCancellationRequested();
+
+                switch (direct.kind) {
+                    case SyntaxKind.CallExpression:
+                        if (!isAvailableThroughGlobal) {
+                            const parent = direct.parent!;
+                            if (exportKind === ExportKind.ExportEquals && parent.kind === SyntaxKind.VariableDeclaration) {
+                                const { name } = parent as ts.VariableDeclaration;
+                                if (name.kind === SyntaxKind.Identifier) {
+                                    directImports.push(name);
+                                    break;
+                                }
+                            }
+
+                            // Don't support re-exporting 'require()' calls, so just add a single indirect user.
+                            addIndirectUser(direct.getSourceFile());
+                        }
+                        break;
+
+                    case SyntaxKind.ImportEqualsDeclaration:
+                        handleNamespaceImport(direct, direct.name, hasModifier(direct, ModifierFlags.Export));
+                        break;
+
+                    case SyntaxKind.ImportDeclaration:
+                        const namedBindings = direct.importClause && direct.importClause.namedBindings;
+                        if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) {
+                            handleNamespaceImport(direct, namedBindings.name);
+                        }
+                        else {
+                            directImports.push(direct);
+                        }
+                        break;
+
+                    case SyntaxKind.ExportDeclaration:
+                        if (!direct.exportClause) {
+                            // This is `export * from "foo"`, so imports of this module may import the export too.
+                            handleDirectImports(getContainingModuleSymbol(direct, checker));
+                        }
+                        else {
+                            // This is `export { foo } from "foo"` and creates an alias symbol, so recursive search will get handle re-exports.
+                            directImports.push(direct);
+                        }
+                        break;
+                }
+            }
+        }
+
+        function handleNamespaceImport(importDeclaration: ImportEqualsDeclaration | ImportDeclaration, name: Identifier, isReExport?: boolean): void {
+            if (exportKind === ExportKind.ExportEquals) {
+                // This is a direct import, not import-as-namespace.
+                directImports.push(importDeclaration);
+            }
+            else if (!isAvailableThroughGlobal) {
+                const sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration);
+                Debug.assert(sourceFileLike.kind === SyntaxKind.SourceFile || sourceFileLike.kind === SyntaxKind.ModuleDeclaration);
+                if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) {
+                    addIndirectUsers(sourceFileLike);
+                }
+                else {
+                    addIndirectUser(sourceFileLike);
+                }
+            }
+        }
+
+        function addIndirectUser(sourceFileLike: SourceFileLike): boolean {
+            Debug.assert(!isAvailableThroughGlobal);
+            const isNew = markSeenIndirectUser(sourceFileLike);
+            if (isNew) {
+                indirectUserDeclarations.push(sourceFileLike);
+            }
+            return isNew;
+        }
+
+        /** Adds a module and all of its transitive dependencies as possible indirect users. */
+        function addIndirectUsers(sourceFileLike: SourceFileLike): void {
+            if (!addIndirectUser(sourceFileLike)) {
+                return;
+            }
+
+            const moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol);
+            Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module));
+            const directImports = getDirectImports(moduleSymbol);
+            if (directImports) for (const directImport of directImports) {
+                addIndirectUsers(getSourceFileLikeForImportDeclaration(directImport));
+            }
+        }
+
+        function getDirectImports(moduleSymbol: Symbol): ImporterOrCallExpression[] | undefined {
+            return allDirectImports.get(getSymbolId(moduleSymbol).toString());
+        }
+    }
+
+    /**
+     * Given the set of direct imports of a module, we need to find which ones import the particular exported symbol.
+     * The returned `importSearches` will result in the entire source file being searched.
+     * But re-exports will be placed in 'singleReferences' since they cannot be locally referenced.
+     */
+    function getSearchesFromDirectImports(directImports: Importer[], exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker, isForRename: boolean): Pick<ImportsResult, "importSearches" | "singleReferences"> {
+        const exportName = exportSymbol.name;
+        const importSearches: Array<[Identifier, Symbol]> = [];
+        const singleReferences: Identifier[] = [];
+        function addSearch(location: Identifier, symbol: Symbol): void {
+            importSearches.push([location, symbol]);
+        }
+
+        if (directImports) for (const decl of directImports) {
+            handleImport(decl);
+        }
+
+        return { importSearches, singleReferences };
+
+        function handleImport(decl: Importer): void {
+            if (decl.kind === SyntaxKind.ImportEqualsDeclaration) {
+                if (isExternalModuleImportEquals(decl)) {
+                    handleNamespaceImportLike(decl.name);
+                }
+                return;
+            }
+
+            if (decl.kind === ts.SyntaxKind.Identifier) {
+                handleNamespaceImportLike(decl);
+                return;
+            }
+
+            // Ignore if there's a grammar error
+            if (decl.moduleSpecifier.kind !== SyntaxKind.StringLiteral) {
+                return;
+            }
+
+            if (decl.kind === SyntaxKind.ExportDeclaration) {
+                searchForNamedImport(decl.exportClause);
+                return;
+            }
+
+            const { importClause } = decl;
+
+            const { namedBindings } = importClause;
+            if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) {
+                handleNamespaceImportLike(namedBindings.name);
+                return;
+            }
+
+            if (exportKind === ExportKind.Named) {
+                searchForNamedImport(namedBindings as NamedImports | undefined);
+            }
+            else {
+                // `export =` might be imported by a default import if `--allowSyntheticDefaultImports` is on, so this handles both ExportKind.Default and ExportKind.ExportEquals
+                const { name } = importClause;
+                // If a default import has the same name as the default export, allow to rename it.
+                // Given `import f` and `export default function f`, we will rename both, but for `import g` we will rename just that.
+                if (name && (!isForRename || name.text === symbolName(exportSymbol))) {
+                    const defaultImportAlias = checker.getSymbolAtLocation(name);
+                    addSearch(name, defaultImportAlias);
+                }
+
+                // 'default' might be accessed as a named import `{ default as foo }`.
+                if (!isForRename && exportKind === ExportKind.Default) {
+                    Debug.assert(exportName === "default");
+                    searchForNamedImport(namedBindings as NamedImports | undefined);
+                }
+            }
+        }
+
+        /**
+         * `import x = require("./x") or `import * as x from "./x"`.
+         * An `export =` may be imported by this syntax, so it may be a direct import.
+         * If it's not a direct import, it will be in `indirectUsers`, so we don't have to do anything here.
+         */
+        function handleNamespaceImportLike(importName: Identifier): void {
+            // Don't rename an import that already has a different name than the export.
+            if (exportKind === ExportKind.ExportEquals && (!isForRename || importName.text === exportName)) {
+                addSearch(importName, checker.getSymbolAtLocation(importName));
+            }
+        }
+
+        function searchForNamedImport(namedBindings: NamedImportsOrExports | undefined): void {
+            if (namedBindings) for (const element of namedBindings.elements) {
+                const { name, propertyName } = element;
+                if ((propertyName || name).text !== exportName) {
+                    continue;
+                }
+
+                if (propertyName) {
+                    // This is `import { foo as bar } from "./a"` or `export { foo as bar } from "./a"`. `foo` isn't a local in the file, so just add it as a single reference.
+                    singleReferences.push(propertyName);
+                    if (!isForRename) { // If renaming `foo`, don't touch `bar`, just `foo`.
+                        // Search locally for `bar`.
+                        addSearch(name, checker.getSymbolAtLocation(name));
+                    }
+                }
+                else {
+                    const localSymbol = element.kind === SyntaxKind.ExportSpecifier && element.propertyName
+                        ? checker.getExportSpecifierLocalTargetSymbol(element) // For re-exporting under a different name, we want to get the re-exported symbol.
+                        : checker.getSymbolAtLocation(name);
+                    addSearch(name, localSymbol);
+                }
+            }
+        }
+    }
+
+    /** Returns 'true' is the namespace 'name' is re-exported from this module, and 'false' if it is only used locally. */
+    function findNamespaceReExports(sourceFileLike: SourceFileLike, name: Identifier, checker: TypeChecker): boolean {
+        const namespaceImportSymbol = checker.getSymbolAtLocation(name);
+
+        return forEachPossibleImportOrExportStatement(sourceFileLike, statement => {
+            if (statement.kind !== SyntaxKind.ExportDeclaration) return;
+
+            const { exportClause, moduleSpecifier } = statement as ExportDeclaration;
+            if (moduleSpecifier || !exportClause) return;
+
+            for (const element of exportClause.elements) {
+                if (checker.getExportSpecifierLocalTargetSymbol(element) === namespaceImportSymbol) {
+                    return true;
+                }
+            }
+        });
+    }
+
+    /** Returns a map from a module symbol Id to all import statements that directly reference the module. */
+    function getDirectImportsMap(sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): Map<ImporterOrCallExpression[]> {
+        const map = createMap<ImporterOrCallExpression[]>();
+
+        for (const sourceFile of sourceFiles) {
+            cancellationToken.throwIfCancellationRequested();
+            forEachImport(sourceFile, (importDecl, moduleSpecifier) => {
+                const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
+                if (moduleSymbol) {
+                    const id = getSymbolId(moduleSymbol).toString();
+                    let imports = map.get(id);
+                    if (!imports) {
+                        map.set(id, imports = []);
+                    }
+                    imports.push(importDecl);
+                }
+            });
+        }
+
+        return map;
+    }
+
+    /** Iterates over all statements at the top level or in module declarations. Returns the first truthy result. */
+    function forEachPossibleImportOrExportStatement<T>(sourceFileLike: SourceFileLike, action: (statement: Statement) => T): T {
+        return forEach(sourceFileLike.kind === SyntaxKind.SourceFile ? sourceFileLike.statements : sourceFileLike.body.statements, statement =>
+            action(statement) || (isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action)));
+    }
+
+    /** Calls `action` for each import, re-export, or require() in a file. */
+    function forEachImport(sourceFile: SourceFile, action: (importStatement: ImporterOrCallExpression, imported: StringLiteral) => void): void {
+        if (sourceFile.externalModuleIndicator) {
+            for (const moduleSpecifier of sourceFile.imports) {
+                action(importerFromModuleSpecifier(moduleSpecifier), moduleSpecifier);
+            }
+        }
+        else {
+            forEachPossibleImportOrExportStatement(sourceFile, statement => {
+                switch (statement.kind) {
+                    case SyntaxKind.ExportDeclaration:
+                    case SyntaxKind.ImportDeclaration: {
+                        const decl = statement as ImportDeclaration | ExportDeclaration;
+                        if (decl.moduleSpecifier && decl.moduleSpecifier.kind === SyntaxKind.StringLiteral) {
+                            action(decl, decl.moduleSpecifier as StringLiteral);
+                        }
+                        break;
+                    }
+
+                    case SyntaxKind.ImportEqualsDeclaration: {
+                        const decl = statement as ImportEqualsDeclaration;
+                        const { moduleReference } = decl;
+                        if (moduleReference.kind === SyntaxKind.ExternalModuleReference &&
+                            moduleReference.expression.kind === SyntaxKind.StringLiteral) {
+                            action(decl, moduleReference.expression as StringLiteral);
+                        }
+                        break;
+                    }
+                }
+            });
+
+            if (sourceFile.flags & NodeFlags.JavaScriptFile) {
+                // Find all 'require()' calls.
+                sourceFile.forEachChild(function recur(node: Node): void {
+                    if (isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
+                        action(node, node.arguments[0] as StringLiteral);
+                    } else {
+                        node.forEachChild(recur);
+                    }
+                });
+            }
+        }
+    }
+
+    function importerFromModuleSpecifier(moduleSpecifier: StringLiteral): Importer {
+        const decl = moduleSpecifier.parent;
+        if (decl.kind === SyntaxKind.ImportDeclaration || decl.kind === SyntaxKind.ExportDeclaration) {
+            return decl as ImportDeclaration | ExportDeclaration;
+        }
+        Debug.assert(decl.kind === SyntaxKind.ExternalModuleReference);
+        return (decl as ExternalModuleReference).parent;
+    }
+
+    export interface ImportedSymbol {
+        kind: ImportExport.Import;
+        symbol: Symbol;
+        isNamedImport: boolean;
+    }
+    export interface ExportedSymbol {
+        kind: ImportExport.Export;
+        symbol: Symbol;
+        exportInfo: ExportInfo;
+    }
+    /**
+     * Given a local reference, we might notice that it's an import/export and recursively search for references of that.
+     * If at an import, look locally for the symbol it imports.
+     * If an an export, look for all imports of it.
+     * This doesn't handle export specifiers; that is done in `getReferencesAtExportSpecifier`.
+     * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here.
+     */
+    export function getImportOrExportSymbol(node: Node, symbol: Symbol, checker: TypeChecker, comingFromExport: boolean): ImportedSymbol | ExportedSymbol | undefined {
+        return comingFromExport ? getExport() : getExport() || getImport();
+
+        function getExport(): ExportedSymbol | ImportedSymbol | undefined {
+            const { parent } = node;
+            if (symbol.flags & SymbolFlags.Export) {
+                if (parent.kind === SyntaxKind.PropertyAccessExpression) {
+                    // When accessing an export of a JS module, there's no alias. The symbol will still be flagged as an export even though we're at the use.
+                    // So check that we are at the declaration.
+                    return symbol.declarations.some(d => d === parent) && parent.parent.kind === ts.SyntaxKind.BinaryExpression
+                        ? getSpecialPropertyExport(parent.parent as ts.BinaryExpression, /*useLhsSymbol*/ false)
+                        : undefined;
+                }
+                else {
+                    const { exportSymbol } = symbol;
+                    Debug.assert(!!exportSymbol);
+                    return exportInfo(exportSymbol, getExportKindForDeclaration(parent));
+                }
+            }
+            else {
+                const exportNode = parent.kind === SyntaxKind.VariableDeclaration ? getAncestor(parent, SyntaxKind.VariableStatement) : parent;
+                if (hasModifier(exportNode, ModifierFlags.Export)) {
+                    if (exportNode.kind === SyntaxKind.ImportEqualsDeclaration && (exportNode as ImportEqualsDeclaration).moduleReference === node) {
+                        // We're at `Y` in `export import X = Y`. This is not the exported symbol, the left-hand-side is. So treat this as an import statement.
+                        if (comingFromExport) {
+                            return undefined;
+                        }
+
+                        const lhsSymbol = checker.getSymbolAtLocation((exportNode as ImportEqualsDeclaration).name);
+                        return { kind: ImportExport.Import, symbol: lhsSymbol, isNamedImport: false };
+                    }
+                    else {
+                        return exportInfo(symbol, getExportKindForDeclaration(exportNode));
+                    }
+                }
+                else if (parent.kind === SyntaxKind.ExportAssignment) {
+                    // Get the symbol for the `export =` node; its parent is the module it's the export of.
+                    const exportingModuleSymbol = parent.symbol.parent;
+                    Debug.assert(!!exportingModuleSymbol);
+                    return { kind: ImportExport.Export, symbol, exportInfo: { exportingModuleSymbol, exportKind: ExportKind.ExportEquals } };
+                }
+                else if (parent.kind === ts.SyntaxKind.BinaryExpression) {
+                    return getSpecialPropertyExport(parent as ts.BinaryExpression, /*useLhsSymbol*/ true);
+                }
+                else if (parent.parent.kind === SyntaxKind.BinaryExpression) {
+                    return getSpecialPropertyExport(parent.parent as ts.BinaryExpression, /*useLhsSymbol*/ true);
+                }
+            }
+
+            function getSpecialPropertyExport(node: ts.BinaryExpression, useLhsSymbol: boolean): ExportedSymbol | undefined {
+                let kind: ExportKind;
+                switch (getSpecialPropertyAssignmentKind(node)) {
+                    case SpecialPropertyAssignmentKind.ExportsProperty:
+                        kind = ExportKind.Named;
+                        break;
+                    case SpecialPropertyAssignmentKind.ModuleExports:
+                        kind = ExportKind.ExportEquals;
+                        break;
+                    default:
+                        return undefined;
+                }
+
+                const sym = useLhsSymbol ? checker.getSymbolAtLocation((node.left as ts.PropertyAccessExpression).name) : symbol;
+                return sym && exportInfo(sym, kind);
+            }
+        }
+
+        function getImport(): ImportedSymbol | undefined {
+            const isImport = isNodeImport(node);
+            if (!isImport) return;
+
+            // A symbol being imported is always an alias. So get what that aliases to find the local symbol.
+            let importedSymbol = checker.getImmediateAliasedSymbol(symbol);
+            if (importedSymbol) {
+                // Search on the local symbol in the exporting module, not the exported symbol.
+                importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker);
+                // Similarly, skip past the symbol for 'export ='
+                if (importedSymbol.name === "export=") {
+                    importedSymbol = checker.getImmediateAliasedSymbol(importedSymbol);
+                }
+
+                if (symbolName(importedSymbol) === symbol.name) { // If this is a rename import, do not continue searching.
+                    return { kind: ImportExport.Import, symbol: importedSymbol, ...isImport };
+                }
+            }
+        }
+
+        function exportInfo(symbol: Symbol, kind: ExportKind): ExportedSymbol {
+            const exportInfo = getExportInfo(symbol, kind, checker);
+            return exportInfo && { kind: ImportExport.Export, symbol, exportInfo };
+        }
+
+        // Not meant for use with export specifiers or export assignment.
+        function getExportKindForDeclaration(node: Node): ExportKind | undefined {
+            return hasModifier(node, ModifierFlags.Default) ? ExportKind.Default : ExportKind.Named;
+        }
+    }
+
+    function isNodeImport(node: Node): { isNamedImport: boolean } | undefined {
+        const { parent } = node;
+        switch (parent.kind) {
+            case SyntaxKind.ImportEqualsDeclaration:
+                return (parent as ImportEqualsDeclaration).name === node && isExternalModuleImportEquals(parent as ImportEqualsDeclaration)
+                    ? { isNamedImport: false }
+                    : undefined;
+            case SyntaxKind.ImportSpecifier:
+                // For a rename import `{ foo as bar }`, don't search for the imported symbol. Just find local uses of `bar`.
+                return (parent as ImportSpecifier).propertyName ? undefined : { isNamedImport: true };
+            case SyntaxKind.ImportClause:
+            case SyntaxKind.NamespaceImport:
+                Debug.assert((parent as ImportClause | NamespaceImport).name === node);
+                return { isNamedImport: false };
+            default:
+                return undefined;
+        }
+    }
+
+    export function getExportInfo(exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker): ExportInfo | undefined {
+        const exportingModuleSymbol = checker.getMergedSymbol(exportSymbol.parent); // Need to get merged symbol in case there's an augmentation.
+        // `export` may appear in a namespace. In that case, just rely on global search.
+        return isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol, exportKind } : undefined;
+    }
+
+    function symbolName(symbol: Symbol): string {
+        if (symbol.name !== "default") {
+            return symbol.name;
+        }
+
+        const name = forEach(symbol.declarations, ({ name }) => name && name.kind === SyntaxKind.Identifier && name.text);
+        Debug.assert(!!name);
+        return name;
+    }
+
+    /** If at an export specifier, go to the symbol it refers to. */
+    function skipExportSpecifierSymbol(symbol: Symbol, checker: TypeChecker): Symbol {
+        // For `export { foo } from './bar", there's nothing to skip, because it does  not create a new alias. But `export { foo } does.
+        if (symbol.declarations) for (const declaration of symbol.declarations) {
+            if (isExportSpecifier(declaration) && !(declaration as ExportSpecifier).propertyName && !(declaration as ExportSpecifier).parent.parent.moduleSpecifier) {
+                return checker.getExportSpecifierLocalTargetSymbol(declaration);
+            }
+        }
+
+        return symbol;
+    }
+
+    function getContainingModuleSymbol(importer: Importer, checker: TypeChecker): Symbol {
+        return checker.getMergedSymbol(getSourceFileLikeForImportDeclaration(importer).symbol);
+    }
+
+    function getSourceFileLikeForImportDeclaration(node: ImporterOrCallExpression): SourceFileLike {
+        if (node.kind === SyntaxKind.CallExpression) {
+            return node.getSourceFile();
+        }
+
+        const { parent } = node;
+
+        if (parent.kind === SyntaxKind.SourceFile) {
+            return parent as SourceFile;
+        }
+        Debug.assert(parent.kind === SyntaxKind.ModuleBlock && isAmbientModuleDeclaration(parent.parent));
+        return parent.parent as AmbientModuleDeclaration;
+    }
+
+    function isAmbientModuleDeclaration(node: Node): node is AmbientModuleDeclaration {
+        return node.kind === SyntaxKind.ModuleDeclaration && (node as ModuleDeclaration).name.kind === SyntaxKind.StringLiteral;
+    }
+
+    function isExternalModuleImportEquals({ moduleReference }: ImportEqualsDeclaration): boolean {
+        return moduleReference.kind === SyntaxKind.ExternalModuleReference && moduleReference.expression.kind === SyntaxKind.StringLiteral;
+    }
+}
diff --git a/src/services/rename.ts b/src/services/rename.ts
index 2e9396888ef..27c47179052 100644
--- a/src/services/rename.ts
+++ b/src/services/rename.ts
@@ -31,21 +31,25 @@ namespace ts.Rename {
                     return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library);
                 }
 
+                // Cannot rename `default` as in `import { default as foo } from "./someModule";
+                if (node.kind === SyntaxKind.Identifier &&
+                        (node as Identifier).originalKeywordKind === SyntaxKind.DefaultKeyword &&
+                        symbol.parent.flags & ts.SymbolFlags.Module) {
+                    return undefined;
+                }
+
                 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);
+            if (isDefinedInLibraryFile(node)) {
+                return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library);
             }
+
+            const displayName = stripQuotes((node as StringLiteral).text);
+            return getRenameInfoSuccess(displayName, displayName, ScriptElementKind.variableElement, ScriptElementKindModifier.none, node, sourceFile);
         }
     }
 
@@ -84,8 +88,9 @@ namespace ts.Rename {
         return createTextSpan(start, width);
     }
 
-    function nodeIsEligibleForRename(node: Node) {
-        return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral ||
+    function nodeIsEligibleForRename(node: Node): boolean {
+        return node.kind === ts.SyntaxKind.Identifier ||
+            node.kind === SyntaxKind.StringLiteral ||
             isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
             isThis(node);
     }
diff --git a/src/services/services.ts b/src/services/services.ts
index 8ccc1d379d6..5624c48a535 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -10,7 +10,6 @@
 /// <reference path='documentRegistry.ts' />
 /// <reference path='findAllReferences.ts' />
 /// <reference path='goToDefinition.ts' />
-/// <reference path='goToImplementation.ts' />
 /// <reference path='jsDoc.ts' />
 /// <reference path='jsTyping.ts' />
 /// <reference path='navigateTo.ts' />
@@ -502,8 +501,8 @@ namespace ts {
         public nameTable: Map<number>;
         public resolvedModules: Map<ResolvedModuleFull>;
         public resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective>;
-        public imports: LiteralExpression[];
-        public moduleAugmentations: LiteralExpression[];
+        public imports: StringLiteral[];
+        public moduleAugmentations: StringLiteral[];
         private namedDeclarations: Map<Declaration[]>;
         public ambientModuleNames: string[];
         public checkJsDirective: CheckJsDirective | undefined;
@@ -1410,18 +1409,18 @@ namespace ts {
             return GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
         }
 
-        /// Goto implementation
-        function getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[] {
-            synchronizeHostData();
-            return GoToImplementation.getImplementationAtPosition(program.getTypeChecker(), cancellationToken,
-                program.getSourceFiles(), getTouchingPropertyName(getValidSourceFile(fileName), position));
-        }
-
         function getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] {
             synchronizeHostData();
             return GoToDefinition.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position);
         }
 
+        /// Goto implementation
+        function getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[] {
+            synchronizeHostData();
+            return FindAllReferences.getImplementationsAtPosition(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
+        }
+
+        /// References and Occurrences
         function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
             let results = getOccurrencesAtPositionCore(fileName, position);
 
@@ -1443,10 +1442,7 @@ namespace ts {
             return DocumentHighlights.getDocumentHighlights(program.getTypeChecker(), cancellationToken, sourceFile, position, sourceFilesToSearch);
         }
 
-        /// References and Occurrences
         function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] {
-            synchronizeHostData();
-
             return convertDocumentHighlights(getDocumentHighlights(fileName, position, [fileName]));
 
             function convertDocumentHighlights(documentHighlights: DocumentHighlights[]): ReferenceEntry[] {
@@ -1472,24 +1468,21 @@ namespace ts {
         }
 
         function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[] {
-            const referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments, /*isForRename*/ true);
-            return FindAllReferences.convertReferences(referencedSymbols);
+            return getReferences(fileName, position, { findInStrings, findInComments, isForRename: true });
         }
 
         function getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
-            const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/ false);
-            return FindAllReferences.convertReferences(referencedSymbols);
+            return getReferences(fileName, position);
+        }
+
+        function getReferences(fileName: string, position: number, options?: FindAllReferences.Options) {
+            synchronizeHostData();
+            return FindAllReferences.findReferencedEntries(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, options);
         }
 
         function findReferences(fileName: string, position: number): ReferencedSymbol[] {
-            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, isForRename: boolean): ReferencedSymbol[] {
             synchronizeHostData();
-            return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position, findInStrings, findInComments, isForRename);
+            return FindAllReferences.findReferencedSymbols(program.getTypeChecker(), cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
         }
 
         /// NavigateTo
@@ -2013,6 +2006,7 @@ namespace ts {
     }
 
     /* @internal */
+    /** Names in the name table are escaped, so an identifier `__foo` will have a name table entry `___foo`. */
     export function getNameTable(sourceFile: SourceFile): Map<number> {
         if (!sourceFile.nameTable) {
             initializeNameTable(sourceFile);
diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json
index 6b40c71e204..978195a31f6 100644
--- a/src/services/tsconfig.json
+++ b/src/services/tsconfig.json
@@ -46,8 +46,8 @@
         "documentHighlights.ts",
         "documentRegistry.ts",
         "findAllReferences.ts",
+        "importTracker.ts",
         "goToDefinition.ts",
-        "goToImplementation.ts",
         "jsDoc.ts",
         "jsTyping.ts",
         "navigateTo.ts",
diff --git a/src/services/types.ts b/src/services/types.ts
index 62fbf18cddf..b1137bc4bc9 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -483,12 +483,9 @@ namespace ts {
         displayParts: SymbolDisplayPart[];
     }
 
-    export interface ReferencedSymbolOf<T extends DocumentSpan> {
+    export interface ReferencedSymbol {
         definition: ReferencedSymbolDefinitionInfo;
-        references: T[];
-    }
-
-    export interface ReferencedSymbol extends ReferencedSymbolOf<ReferenceEntry> {
+        references: ReferenceEntry[];
     }
 
     export enum SymbolDisplayPartKind {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index fe9a310ad4b..815faac7417 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -364,15 +364,6 @@ namespace ts {
         }
     }
 
-    export function getStringLiteralTypeForNode(node: StringLiteral | LiteralTypeNode, typeChecker: TypeChecker): LiteralType {
-        const searchNode = node.parent.kind === SyntaxKind.LiteralType ? <LiteralTypeNode>node.parent : node;
-        const type = typeChecker.getTypeAtLocation(searchNode);
-        if (type && type.flags & TypeFlags.StringLiteral) {
-            return <LiteralType>type;
-        }
-        return undefined;
-    }
-
     export function isThis(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.ThisKeyword:
@@ -1132,6 +1123,21 @@ namespace ts {
                 return false;
         }
     }
+
+    /** True if the symbol is for an external module, as opposed to a namespace. */
+    export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean {
+        Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module));
+        return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote;
+    }
+
+    /** Returns `true` the first time it encounters a node and `false` afterwards. */
+    export function nodeSeenTracker<T extends Node>(): (node: T) => boolean {
+        const seen: Array<true> = [];
+        return node => {
+            const id = getNodeId(node);
+            return !seen[id] && (seen[id] = true);
+        };
+    }
 }
 
 // Display-part writer helpers
@@ -1300,21 +1306,14 @@ namespace ts {
     export function getDeclaredName(typeChecker: TypeChecker, 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 is under the cursor.
-        if (isImportOrExportSpecifierName(location)) {
-            return location.getText();
-        }
-        else if (isStringOrNumericLiteral(location) &&
-            location.parent.kind === SyntaxKind.ComputedPropertyName) {
-            return (<LiteralExpression>location).text;
+        if (isImportOrExportSpecifierName(location) || isStringOrNumericLiteral(location) && location.parent.kind === SyntaxKind.ComputedPropertyName) {
+            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);
-
-        const name = typeChecker.symbolToString(localExportDefaultSymbol || symbol);
-
-        return name;
+        return typeChecker.symbolToString(localExportDefaultSymbol || symbol);
     }
 
     export function isImportOrExportSpecifierName(location: Node): location is Identifier {
diff --git a/tests/baselines/reference/2dArrays.types b/tests/baselines/reference/2dArrays.types
index cd5ddc0efa5..45672187306 100644
--- a/tests/baselines/reference/2dArrays.types
+++ b/tests/baselines/reference/2dArrays.types
@@ -26,12 +26,12 @@ class Board {
 
         return this.ships.every(function (val) { return val.isSunk; });
 >this.ships.every(function (val) { return val.isSunk; }) : boolean
->this.ships.every : { (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; }
+>this.ships.every : { (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; }
 >this.ships : Ship[]
 >this : this
 >ships : Ship[]
->every : { (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: undefined, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; }
->function (val) { return val.isSunk; } : (this: undefined, val: Ship) => boolean
+>every : { (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean): boolean; (callbackfn: (this: void, value: Ship, index: number, array: Ship[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Ship, index: number, array: Ship[]) => boolean, thisArg: Z): boolean; }
+>function (val) { return val.isSunk; } : (this: void, val: Ship) => boolean
 >val : Ship
 >val.isSunk : boolean
 >val : Ship
diff --git a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt
index 9fd7043faa6..bc8582debd9 100644
--- a/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt
+++ b/tests/baselines/reference/InvalidNonInstantiatedModule.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2304: Cannot find name 'M'.
-tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2304: Cannot find name 'M'.
+tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(5,9): error TS2708: Cannot use namespace 'M' as a value.
+tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts(7,15): error TS2708: Cannot use namespace 'M' as a value.
 
 
 ==== tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts (2 errors) ====
@@ -9,9 +9,9 @@ tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiate
     
     var m = M; // Error, not instantiated can not be used as var
             ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     
     var x: typeof M; // Error only a namespace
                   ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
index 009d405c0f5..66d9eebb3dd 100644
--- a/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
+++ b/tests/baselines/reference/aliasOnMergedModuleInterface.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2304: Cannot find name 'foo'.
+tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2708: Cannot use namespace 'foo' as a value.
 
 
 ==== tests/cases/compiler/aliasOnMergedModuleInterface_1.ts (1 errors) ====
@@ -8,7 +8,7 @@ tests/cases/compiler/aliasOnMergedModuleInterface_1.ts(5,16): error TS2304: Cann
     z.bar("hello"); // This should be ok
     var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
                    ~~~
-!!! error TS2304: Cannot find name 'foo'.
+!!! error TS2708: Cannot use namespace 'foo' as a value.
     
 ==== tests/cases/compiler/aliasOnMergedModuleInterface_0.ts (0 errors) ====
     declare module "foo"
diff --git a/tests/baselines/reference/anonymousClassExpression2.errors.txt b/tests/baselines/reference/anonymousClassExpression2.errors.txt
new file mode 100644
index 00000000000..c9b59ae9c4d
--- /dev/null
+++ b/tests/baselines/reference/anonymousClassExpression2.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/compiler/anonymousClassExpression2.ts(13,18): error TS2339: Property 'methodA' does not exist on type 'B'.
+
+
+==== tests/cases/compiler/anonymousClassExpression2.ts (1 errors) ====
+    // Fixes #14860
+    // note: repros with `while (0);` too
+    // but it's less inscrutable and more obvious to put it *inside* the loop
+    while (0) {
+        class A {
+            methodA() {
+                this; //note: a this reference of some kind is required to trigger the bug
+            }
+        }
+    
+        class B {
+            methodB() {
+                this.methodA; // error
+                     ~~~~~~~
+!!! error TS2339: Property 'methodA' does not exist on type 'B'.
+                this.methodB; // ok
+            }
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/anonymousClassExpression2.js b/tests/baselines/reference/anonymousClassExpression2.js
new file mode 100644
index 00000000000..a1da8d5fb10
--- /dev/null
+++ b/tests/baselines/reference/anonymousClassExpression2.js
@@ -0,0 +1,43 @@
+//// [anonymousClassExpression2.ts]
+// Fixes #14860
+// note: repros with `while (0);` too
+// but it's less inscrutable and more obvious to put it *inside* the loop
+while (0) {
+    class A {
+        methodA() {
+            this; //note: a this reference of some kind is required to trigger the bug
+        }
+    }
+
+    class B {
+        methodB() {
+            this.methodA; // error
+            this.methodB; // ok
+        }
+    }
+}
+
+
+//// [anonymousClassExpression2.js]
+// Fixes #14860
+// note: repros with `while (0);` too
+// but it's less inscrutable and more obvious to put it *inside* the loop
+while (0) {
+    var A = (function () {
+        function A() {
+        }
+        A.prototype.methodA = function () {
+            this; //note: a this reference of some kind is required to trigger the bug
+        };
+        return A;
+    }());
+    var B = (function () {
+        function B() {
+        }
+        B.prototype.methodB = function () {
+            this.methodA; // error
+            this.methodB; // ok
+        };
+        return B;
+    }());
+}
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.types b/tests/baselines/reference/anyInferenceAnonymousFunctions.types
index ee176215421..b015d350760 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.types
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.types
@@ -57,10 +57,10 @@ paired.reduce((b3, b4) => b3.concat({}), []);
 
 paired.map((c1) => c1.count);
 >paired.map((c1) => c1.count) : any[]
->paired.map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>paired.map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >paired : any[]
->map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
->(c1) => c1.count : (this: undefined, c1: any) => any
+>map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>(c1) => c1.count : (this: void, c1: any) => any
 >c1 : any
 >c1.count : any
 >c1 : any
@@ -68,10 +68,10 @@ paired.map((c1) => c1.count);
 
 paired.map(function (c2) { return c2.count; });
 >paired.map(function (c2) { return c2.count; }) : any[]
->paired.map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>paired.map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >paired : any[]
->map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
->function (c2) { return c2.count; } : (this: undefined, c2: any) => any
+>map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>function (c2) { return c2.count; } : (this: void, c2: any) => any
 >c2 : any
 >c2.count : any
 >c2 : any
diff --git a/tests/baselines/reference/argumentsAsPropertyName.types b/tests/baselines/reference/argumentsAsPropertyName.types
index 00773d2a3cf..73397199436 100644
--- a/tests/baselines/reference/argumentsAsPropertyName.types
+++ b/tests/baselines/reference/argumentsAsPropertyName.types
@@ -42,13 +42,13 @@ function myFunction(myType: MyType) {
 
         [1, 2, 3].forEach(function(j) { use(x); })
 >[1, 2, 3].forEach(function(j) { use(x); }) : void
->[1, 2, 3].forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
+>[1, 2, 3].forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
->function(j) { use(x); } : (this: undefined, j: number) => void
+>forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
+>function(j) { use(x); } : (this: void, j: number) => void
 >j : number
 >use(x) : any
 >use : (s: any) => any
diff --git a/tests/baselines/reference/arrayConcatMap.types b/tests/baselines/reference/arrayConcatMap.types
index da4e998f92c..b234b7beb26 100644
--- a/tests/baselines/reference/arrayConcatMap.types
+++ b/tests/baselines/reference/arrayConcatMap.types
@@ -2,7 +2,7 @@
 var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >x : any[]
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map(b => b.a) : any[]
->[].concat([{ a: 1 }], [{ a: 2 }])          .map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>[].concat([{ a: 1 }], [{ a: 2 }])          .map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
 >[].concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
 >[] : undefined[]
@@ -17,8 +17,8 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >2 : 2
 
           .map(b => b.a);
->map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
->b => b.a : (this: undefined, b: any) => any
+>map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>b => b.a : (this: void, b: any) => any
 >b : any
 >b.a : any
 >b : any
diff --git a/tests/baselines/reference/arrayFilter.types b/tests/baselines/reference/arrayFilter.types
index de11296f832..23ab4d915bd 100644
--- a/tests/baselines/reference/arrayFilter.types
+++ b/tests/baselines/reference/arrayFilter.types
@@ -22,10 +22,10 @@ var foo = [
 
 foo.filter(x => x.name); //should accepted all possible types not only boolean! 
 >foo.filter(x => x.name) : { name: string; }[]
->foo.filter : { (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; <Z>(callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; }
+>foo.filter : { (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; <Z>(callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; }
 >foo : { name: string; }[]
->filter : { (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: undefined, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; <Z>(callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; }
->x => x.name : (this: undefined, x: { name: string; }) => string
+>filter : { (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any): { name: string; }[]; (callbackfn: (this: void, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: undefined): { name: string; }[]; <Z>(callbackfn: (this: Z, value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg: Z): { name: string; }[]; }
+>x => x.name : (this: void, x: { name: string; }) => string
 >x : { name: string; }
 >x.name : string
 >x : { name: string; }
diff --git a/tests/baselines/reference/assignToModule.errors.txt b/tests/baselines/reference/assignToModule.errors.txt
index 26121d72a05..0b8b6f27deb 100644
--- a/tests/baselines/reference/assignToModule.errors.txt
+++ b/tests/baselines/reference/assignToModule.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/assignToModule.ts(2,1): error TS2304: Cannot find name 'A'.
+tests/cases/compiler/assignToModule.ts(2,1): error TS2708: Cannot use namespace 'A' as a value.
 
 
 ==== tests/cases/compiler/assignToModule.ts (1 errors) ====
     module A {}
     A = undefined; // invalid LHS
     ~
-!!! error TS2304: Cannot find name 'A'.
\ No newline at end of file
+!!! error TS2708: Cannot use namespace 'A' as a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt
index 7e323479d57..5e42a2e79c6 100644
--- a/tests/baselines/reference/assignmentToReferenceTypes.errors.txt
+++ b/tests/baselines/reference/assignmentToReferenceTypes.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2304: Cannot find name 'M'.
+tests/cases/compiler/assignmentToReferenceTypes.ts(5,1): error TS2708: Cannot use namespace 'M' as a value.
 tests/cases/compiler/assignmentToReferenceTypes.ts(9,1): error TS2539: Cannot assign to 'C' because it is not a variable.
 tests/cases/compiler/assignmentToReferenceTypes.ts(13,1): error TS2539: Cannot assign to 'E' because it is not a variable.
 tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot assign to 'f' because it is not a variable.
@@ -11,7 +11,7 @@ tests/cases/compiler/assignmentToReferenceTypes.ts(16,1): error TS2539: Cannot a
     }
     M = null;
     ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     
     class C {
     }
diff --git a/tests/baselines/reference/assignments.errors.txt b/tests/baselines/reference/assignments.errors.txt
index 86bbe75cd4b..cb8b7a17bdf 100644
--- a/tests/baselines/reference/assignments.errors.txt
+++ b/tests/baselines/reference/assignments.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2304: Cannot find name 'M'.
+tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(11,1): error TS2708: Cannot use namespace 'M' as a value.
 tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(14,1): error TS2539: Cannot assign to 'C' because it is not a variable.
 tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(17,1): error TS2539: Cannot assign to 'E' because it is not a variable.
 tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(18,3): error TS2540: Cannot assign to 'A' because it is a constant or a read-only property.
@@ -19,7 +19,7 @@ tests/cases/conformance/expressions/valuesAndReferences/assignments.ts(31,1): er
     module M { }
     M = null; // Error
     ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     
     class C { }
     C = null; // Error
diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types
index c4728de2ff1..15c5ecd4858 100644
--- a/tests/baselines/reference/bestChoiceType.types
+++ b/tests/baselines/reference/bestChoiceType.types
@@ -3,7 +3,7 @@
 
 (''.match(/ /) || []).map(s => s.toLowerCase());
 >(''.match(/ /) || []).map(s => s.toLowerCase()) : string[]
->(''.match(/ /) || []).map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>(''.match(/ /) || []).map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >(''.match(/ /) || []) : RegExpMatchArray
 >''.match(/ /) || [] : RegExpMatchArray
 >''.match(/ /) : RegExpMatchArray | null
@@ -12,8 +12,8 @@
 >match : (regexp: string | RegExp) => RegExpMatchArray | null
 >/ / : RegExp
 >[] : never[]
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->s => s.toLowerCase() : (this: undefined, s: string) => string
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>s => s.toLowerCase() : (this: void, s: string) => string
 >s : string
 >s.toLowerCase() : string
 >s.toLowerCase : () => string
@@ -42,10 +42,10 @@ function f1() {
     let z = y.map(s => s.toLowerCase());
 >z : string[]
 >y.map(s => s.toLowerCase()) : string[]
->y.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>y.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >y : RegExpMatchArray
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->s => s.toLowerCase() : (this: undefined, s: string) => string
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>s => s.toLowerCase() : (this: void, s: string) => string
 >s : string
 >s.toLowerCase() : string
 >s.toLowerCase : () => string
@@ -74,10 +74,10 @@ function f2() {
     let z = y.map(s => s.toLowerCase());
 >z : string[]
 >y.map(s => s.toLowerCase()) : string[]
->y.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>y.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >y : RegExpMatchArray
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->s => s.toLowerCase() : (this: undefined, s: string) => string
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>s => s.toLowerCase() : (this: void, s: string) => string
 >s : string
 >s.toLowerCase() : string
 >s.toLowerCase : () => string
diff --git a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types
index 7bae17fb922..115930df20a 100644
--- a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types
+++ b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types
@@ -13,10 +13,10 @@ class A {
 
         x.forEach((v) => {
 >x.forEach((v) => {            switch(v) {                case "test": use(this);            }        }) : void
->x.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>x.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
 >x : string[]
->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
->(v) => {            switch(v) {                case "test": use(this);            }        } : (this: undefined, v: string) => void
+>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>(v) => {            switch(v) {                case "test": use(this);            }        } : (this: void, v: string) => void
 >v : string
 
             switch(v) {
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.types b/tests/baselines/reference/classExpressionWithStaticProperties3.types
index ff2871e4d94..6f598e6e42e 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties3.types
+++ b/tests/baselines/reference/classExpressionWithStaticProperties3.types
@@ -41,10 +41,10 @@ for (let i = 0; i < 3; i++) {
 }
 arr.forEach(C => console.log(C.y()));
 >arr.forEach(C => console.log(C.y())) : void
->arr.forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
+>arr.forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
 >arr : { y(): number; }[]
->forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
->C => console.log(C.y()) : (this: undefined, C: { y(): number; }) => any
+>forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
+>C => console.log(C.y()) : (this: void, C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
 >console.log : any
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types
index da771990ee9..b5cd81e8590 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types
@@ -41,10 +41,10 @@ for (let i = 0; i < 3; i++) {
 }
 arr.forEach(C => console.log(C.y()));
 >arr.forEach(C => console.log(C.y())) : void
->arr.forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
+>arr.forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
 >arr : { y(): number; }[]
->forEach : { (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: undefined, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
->C => console.log(C.y()) : (this: undefined, C: { y(): number; }) => any
+>forEach : { (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void): void; (callbackfn: (this: void, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg: Z): void; }
+>C => console.log(C.y()) : (this: void, C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
 >console.log : any
diff --git a/tests/baselines/reference/commaOperatorInConditionalExpression.types b/tests/baselines/reference/commaOperatorInConditionalExpression.types
index de8a95cd6c3..7ee2ab72c77 100644
--- a/tests/baselines/reference/commaOperatorInConditionalExpression.types
+++ b/tests/baselines/reference/commaOperatorInConditionalExpression.types
@@ -5,13 +5,13 @@ function f (m: string) {
 
     [1, 2, 3].map(i => {
 >[1, 2, 3].map(i => {        return true? { [m]: i } : { [m]: i + 1 }    }) : { [x: string]: number; }[]
->[1, 2, 3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>[1, 2, 3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (this: undefined, i: number) => { [x: string]: number; }
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (this: void, i: number) => { [x: string]: number; }
 >i : number
 
         return true? { [m]: i } : { [m]: i + 1 }
diff --git a/tests/baselines/reference/commentInMethodCall.types b/tests/baselines/reference/commentInMethodCall.types
index eebbc15823e..b74323d1477 100644
--- a/tests/baselines/reference/commentInMethodCall.types
+++ b/tests/baselines/reference/commentInMethodCall.types
@@ -5,10 +5,10 @@ var s: string[];
 
 s.map(// do something
 >s.map(// do something    function () { }) : void[]
->s.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>s.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >s : string[]
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 
     function () { });
->function () { } : (this: undefined) => void
+>function () { } : (this: void) => void
 
diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.types b/tests/baselines/reference/contextualSignatureInstantiation3.types
index dcb7284ceaa..60ad7c31bf6 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation3.types
+++ b/tests/baselines/reference/contextualSignatureInstantiation3.types
@@ -13,9 +13,9 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
 
     return items.map(f);
 >items.map(f) : U[]
->items.map : { <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
+>items.map : { <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
 >items : T[]
->map : { <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
 >f : (x: T) => U
 }
 
@@ -54,9 +54,9 @@ var v1: number[];
 var v1 = xs.map(identity);      // Error if not number[]
 >v1 : number[]
 >xs.map(identity) : number[]
->xs.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>xs.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >xs : number[]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >identity : <T>(x: T) => T
 
 var v1 = map(xs, identity);     // Error if not number[]
@@ -72,9 +72,9 @@ var v2: number[][];
 var v2 = xs.map(singleton);     // Error if not number[][]
 >v2 : number[][]
 >xs.map(singleton) : number[][]
->xs.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>xs.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >xs : number[]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >singleton : <T>(x: T) => T[]
 
 var v2 = map(xs, singleton);    // Error if not number[][]
diff --git a/tests/baselines/reference/contextuallyTypedIife.types b/tests/baselines/reference/contextuallyTypedIife.types
index b8c59a618b8..04ddbf50fde 100644
--- a/tests/baselines/reference/contextuallyTypedIife.types
+++ b/tests/baselines/reference/contextuallyTypedIife.types
@@ -105,10 +105,10 @@
 >(...numbers) => numbers.every(n => n > 0) : (...numbers: number[]) => boolean
 >numbers : number[]
 >numbers.every(n => n > 0) : boolean
->numbers.every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>numbers.every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
 >numbers : number[]
->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
->n => n > 0 : (this: undefined, n: number) => boolean
+>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>n => n > 0 : (this: void, n: number) => boolean
 >n : number
 >n > 0 : boolean
 >n : number
@@ -123,10 +123,10 @@
 >(...mixed) => mixed.every(n => !!n) : (...mixed: (string | number)[]) => boolean
 >mixed : (string | number)[]
 >mixed.every(n => !!n) : boolean
->mixed.every : { (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; }
+>mixed.every : { (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; }
 >mixed : (string | number)[]
->every : { (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; }
->n => !!n : (this: undefined, n: string | number) => boolean
+>every : { (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean): boolean; (callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => boolean, thisArg: Z): boolean; }
+>n => !!n : (this: void, n: string | number) => boolean
 >n : string | number
 >!!n : boolean
 >!n : boolean
@@ -141,10 +141,10 @@
 >(...noNumbers) => noNumbers.some(n => n > 0) : (...noNumbers: any[]) => boolean
 >noNumbers : any[]
 >noNumbers.some(n => n > 0) : boolean
->noNumbers.some : { (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; }
+>noNumbers.some : { (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; }
 >noNumbers : any[]
->some : { (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: undefined, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; }
->n => n > 0 : (this: undefined, n: any) => boolean
+>some : { (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean): boolean; (callbackfn: (this: void, value: any, index: number, array: any[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: any, index: number, array: any[]) => boolean, thisArg: Z): boolean; }
+>n => n > 0 : (this: void, n: any) => boolean
 >n : any
 >n > 0 : boolean
 >n : any
@@ -160,10 +160,10 @@
 >first : number
 >[] : undefined[]
 >rest.map(n => n > 0) : boolean[]
->rest.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>rest.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >rest : number[]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n > 0 : (this: undefined, n: number) => boolean
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n > 0 : (this: void, n: number) => boolean
 >n : number
 >n > 0 : boolean
 >n : number
diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.types b/tests/baselines/reference/controlFlowDestructuringParameters.types
index d1adadfee17..7fdb1eded01 100644
--- a/tests/baselines/reference/controlFlowDestructuringParameters.types
+++ b/tests/baselines/reference/controlFlowDestructuringParameters.types
@@ -4,15 +4,15 @@
 
 [{ x: 1 }].map(
 >[{ x: 1 }].map(  ({ x }) => x) : number[]
->[{ x: 1 }].map : { <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; }
+>[{ x: 1 }].map : { <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; }
 >[{ x: 1 }] : { x: number; }[]
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : 1
->map : { <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): [U, U]; <U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; }, { x: number; }], callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg: Z): U[]; }
 
   ({ x }) => x
->({ x }) => x : (this: undefined, {x}: { x: number; }) => number
+>({ x }) => x : (this: void, {x}: { x: number; }) => number
 >x : number
 >x : number
 
diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types
index 70012094bf3..9fafbd0cbd6 100644
--- a/tests/baselines/reference/declarationEmitPromise.types
+++ b/tests/baselines/reference/declarationEmitPromise.types
@@ -44,15 +44,15 @@ export async function runSampleWorks<A, B, C, D, E>(
 >bluebird : typeof bluebird
 >all : bluebird<any>[]
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
->[a, b, c, d, e].filter : { (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
+>[a, b, c, d, e].filter : { (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
 >[a, b, c, d, e] : bluebird<A>[]
 >a : bluebird<A>
 >b : bluebird<B>
 >c : bluebird<C>
 >d : bluebird<D>
 >e : bluebird<E>
->filter : { (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
->el => !!el : (this: undefined, el: bluebird<A>) => boolean
+>filter : { (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
+>el => !!el : (this: void, el: bluebird<A>) => boolean
 >el : bluebird<A>
 >!!el : boolean
 >!el : boolean
@@ -129,15 +129,15 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >bluebird : typeof bluebird
 >all : bluebird<any>[]
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
->[a, b, c, d, e].filter : { (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
+>[a, b, c, d, e].filter : { (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
 >[a, b, c, d, e] : bluebird<A>[]
 >a : bluebird<A>
 >b : bluebird<B>
 >c : bluebird<C>
 >d : bluebird<D>
 >e : bluebird<E>
->filter : { (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: undefined, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
->el => !!el : (this: undefined, el: bluebird<A>) => boolean
+>filter : { (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any): bluebird<A>[]; (callbackfn: (this: void, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: undefined): bluebird<A>[]; <Z>(callbackfn: (this: Z, value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg: Z): bluebird<A>[]; }
+>el => !!el : (this: void, el: bluebird<A>) => boolean
 >el : bluebird<A>
 >!!el : boolean
 >!el : boolean
diff --git a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt
index b0b0f876be4..d46963caeed 100644
--- a/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt
+++ b/tests/baselines/reference/defaultArgsInFunctionExpressions.errors.txt
@@ -5,7 +5,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(11,1): error TS2322: Ty
 tests/cases/compiler/defaultArgsInFunctionExpressions.ts(14,51): error TS2352: Type 'string' cannot be converted to type 'number'.
 tests/cases/compiler/defaultArgsInFunctionExpressions.ts(17,41): error TS2322: Type '""' is not assignable to type 'number'.
 tests/cases/compiler/defaultArgsInFunctionExpressions.ts(20,62): error TS2352: Type 'string' cannot be converted to type 'number'.
-tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2304: Cannot find name 'T'.
+tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2708: Cannot use namespace 'T' as a value.
 
 
 ==== tests/cases/compiler/defaultArgsInFunctionExpressions.ts (8 errors) ====
@@ -52,7 +52,7 @@ tests/cases/compiler/defaultArgsInFunctionExpressions.ts(28,15): error TS2304: C
     
     var f6 = (t = T) => { };
                   ~
-!!! error TS2304: Cannot find name 'T'.
+!!! error TS2708: Cannot use namespace 'T' as a value.
     var f7 = (t = U) => { return t; };
     
     f7().x;
\ No newline at end of file
diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.js b/tests/baselines/reference/emitDecoratorMetadata_object.js
new file mode 100644
index 00000000000..a8c8c360dfc
--- /dev/null
+++ b/tests/baselines/reference/emitDecoratorMetadata_object.js
@@ -0,0 +1,38 @@
+//// [emitDecoratorMetadata_object.ts]
+declare const MyClassDecorator: ClassDecorator;
+declare const MyMethodDecorator: MethodDecorator;
+
+@MyClassDecorator
+class A {
+    constructor(hi: object) {}
+    @MyMethodDecorator
+    method(there: object) {}
+}
+
+
+//// [emitDecoratorMetadata_object.js]
+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);
+};
+var A = (function () {
+    function A(hi) {
+    }
+    A.prototype.method = function (there) { };
+    return A;
+}());
+__decorate([
+    MyMethodDecorator,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], A.prototype, "method", null);
+A = __decorate([
+    MyClassDecorator,
+    __metadata("design:paramtypes", [Object])
+], A);
diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.symbols b/tests/baselines/reference/emitDecoratorMetadata_object.symbols
new file mode 100644
index 00000000000..21cd801fcdd
--- /dev/null
+++ b/tests/baselines/reference/emitDecoratorMetadata_object.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/emitDecoratorMetadata_object.ts ===
+declare const MyClassDecorator: ClassDecorator;
+>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_object.ts, 0, 13))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --))
+
+declare const MyMethodDecorator: MethodDecorator;
+>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_object.ts, 1, 13))
+>MethodDecorator : Symbol(MethodDecorator, Decl(lib.d.ts, --, --))
+
+@MyClassDecorator
+>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_object.ts, 0, 13))
+
+class A {
+>A : Symbol(A, Decl(emitDecoratorMetadata_object.ts, 1, 49))
+
+    constructor(hi: object) {}
+>hi : Symbol(hi, Decl(emitDecoratorMetadata_object.ts, 5, 16))
+
+    @MyMethodDecorator
+>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_object.ts, 1, 13))
+
+    method(there: object) {}
+>method : Symbol(A.method, Decl(emitDecoratorMetadata_object.ts, 5, 30))
+>there : Symbol(there, Decl(emitDecoratorMetadata_object.ts, 7, 11))
+}
+
diff --git a/tests/baselines/reference/emitDecoratorMetadata_object.types b/tests/baselines/reference/emitDecoratorMetadata_object.types
new file mode 100644
index 00000000000..a5d5b2a242a
--- /dev/null
+++ b/tests/baselines/reference/emitDecoratorMetadata_object.types
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/emitDecoratorMetadata_object.ts ===
+declare const MyClassDecorator: ClassDecorator;
+>MyClassDecorator : ClassDecorator
+>ClassDecorator : ClassDecorator
+
+declare const MyMethodDecorator: MethodDecorator;
+>MyMethodDecorator : MethodDecorator
+>MethodDecorator : MethodDecorator
+
+@MyClassDecorator
+>MyClassDecorator : ClassDecorator
+
+class A {
+>A : A
+
+    constructor(hi: object) {}
+>hi : object
+
+    @MyMethodDecorator
+>MyMethodDecorator : MethodDecorator
+
+    method(there: object) {}
+>method : (there: object) => void
+>there : object
+}
+
diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types
index 981ad5c8c81..eb4b4e18e76 100644
--- a/tests/baselines/reference/enumIndexer.types
+++ b/tests/baselines/reference/enumIndexer.types
@@ -25,10 +25,10 @@ var enumValue = MyEnumType.foo;
 var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type
 >x : boolean[]
 >_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[]
->_arr.map : { <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; }
+>_arr.map : { <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; }
 >_arr : { key: string; }[]
->map : { <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; }
->o => MyEnumType[o.key] === enumValue : (this: undefined, o: { key: string; }) => boolean
+>map : { <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): [U, U]; <U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ key: string; }, { key: string; }], callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg: Z): U[]; }
+>o => MyEnumType[o.key] === enumValue : (this: void, o: { key: string; }) => boolean
 >o : { key: string; }
 >MyEnumType[o.key] === enumValue : boolean
 >MyEnumType[o.key] : any
diff --git a/tests/baselines/reference/genericArray1.types b/tests/baselines/reference/genericArray1.types
index b893d9778fc..bf5d55eb569 100644
--- a/tests/baselines/reference/genericArray1.types
+++ b/tests/baselines/reference/genericArray1.types
@@ -14,13 +14,13 @@ interface String{
 var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : number[]
 >["a", "b", "c"].map(x => x.length) : number[]
->["a", "b", "c"].map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>["a", "b", "c"].map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >["a", "b", "c"] : string[]
 >"a" : "a"
 >"b" : "b"
 >"c" : "c"
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->x => x.length : (this: undefined, x: string) => number
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>x => x.length : (this: void, x: string) => number
 >x : string
 >x.length : number
 >x : string
diff --git a/tests/baselines/reference/genericInference1.types b/tests/baselines/reference/genericInference1.types
index 64ff2c399cd..8995e07c825 100644
--- a/tests/baselines/reference/genericInference1.types
+++ b/tests/baselines/reference/genericInference1.types
@@ -1,13 +1,13 @@
 === tests/cases/compiler/genericInference1.ts ===
 ['a', 'b', 'c'].map(x => x.length);
 >['a', 'b', 'c'].map(x => x.length) : number[]
->['a', 'b', 'c'].map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>['a', 'b', 'c'].map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >['a', 'b', 'c'] : string[]
 >'a' : "a"
 >'b' : "b"
 >'c' : "c"
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->x => x.length : (this: undefined, x: string) => number
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>x => x.length : (this: void, x: string) => number
 >x : string
 >x.length : number
 >x : string
diff --git a/tests/baselines/reference/genericMethodOverspecialization.types b/tests/baselines/reference/genericMethodOverspecialization.types
index 36b710b742c..17f3e0dddd7 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.types
+++ b/tests/baselines/reference/genericMethodOverspecialization.types
@@ -34,10 +34,10 @@ interface Document {
 var elements = names.map(function (name) {
 >elements : HTMLElement[]
 >names.map(function (name) {    return document.getElementById(name);}) : HTMLElement[]
->names.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>names.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >names : string[]
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->function (name) {    return document.getElementById(name);} : (this: undefined, name: string) => HTMLElement
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>function (name) {    return document.getElementById(name);} : (this: void, name: string) => HTMLElement
 >name : string
 
     return document.getElementById(name);
@@ -53,10 +53,10 @@ var elements = names.map(function (name) {
 var xxx = elements.filter(function (e) {
 >xxx : HTMLElement[]
 >elements.filter(function (e) {    return !e.isDisabled;}) : HTMLElement[]
->elements.filter : { (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; <Z>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; }
+>elements.filter : { (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; <Z>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; }
 >elements : HTMLElement[]
->filter : { (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; <Z>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; }
->function (e) {    return !e.isDisabled;} : (this: undefined, e: HTMLElement) => boolean
+>filter : { (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any): HTMLElement[]; (callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: undefined): HTMLElement[]; <Z>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg: Z): HTMLElement[]; }
+>function (e) {    return !e.isDisabled;} : (this: void, e: HTMLElement) => boolean
 >e : HTMLElement
 
     return !e.isDisabled;
@@ -70,10 +70,10 @@ var xxx = elements.filter(function (e) {
 var widths:number[] = elements.map(function (e) { // should not error
 >widths : number[]
 >elements.map(function (e) { // should not error    return e.clientWidth;}) : number[]
->elements.map : { <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; <U>(callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; }
+>elements.map : { <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; <U>(callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; }
 >elements : HTMLElement[]
->map : { <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; <U>(callbackfn: (this: undefined, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; }
->function (e) { // should not error    return e.clientWidth;} : (this: undefined, e: HTMLElement) => number
+>map : { <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U, U]; <U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): [U, U]; <U>(this: [HTMLElement, HTMLElement], callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [HTMLElement, HTMLElement], callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U): U[]; <U>(callbackfn: (this: void, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg: Z): U[]; }
+>function (e) { // should not error    return e.clientWidth;} : (this: void, e: HTMLElement) => number
 >e : HTMLElement
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt
index 7635608f58e..276654562a1 100644
--- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt
+++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt
@@ -15,7 +15,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,38): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(20,17): error TS2689: Cannot extend an interface 'I'. Did you mean 'implements'?
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(23,21): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
-tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2304: Cannot find name 'M'.
+tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2708: Cannot use namespace 'M' as a value.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(30,24): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(31,24): error TS2694: Namespace 'M' has no exported member 'C'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(33,22): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
@@ -89,7 +89,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
     
     class D2 extends M.C { }
                      ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     interface D3<T extends M.E> { }
                            ~~~
 !!! error TS2314: Generic type 'E<T>' requires 1 type argument(s).
diff --git a/tests/baselines/reference/implementArrayInterface.errors.txt b/tests/baselines/reference/implementArrayInterface.errors.txt
index 139bb42105d..61c4440fa3a 100644
--- a/tests/baselines/reference/implementArrayInterface.errors.txt
+++ b/tests/baselines/reference/implementArrayInterface.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/implementArrayInterface.ts(1,15): error TS2420: Class 'MyArray<T>' incorrectly implements interface 'T[]'.
   Types of property 'map' are incompatible.
-    Type '<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'.
+    Type '<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'.
       Type 'any[]' is not assignable to type '[any, any, any, any, any]'.
         Property '0' is missing in type 'any[]'.
 
@@ -10,7 +10,7 @@ tests/cases/compiler/implementArrayInterface.ts(1,15): error TS2420: Class 'MyAr
                   ~~~~~~~
 !!! error TS2420: Class 'MyArray<T>' incorrectly implements interface 'T[]'.
 !!! error TS2420:   Types of property 'map' are incompatible.
-!!! error TS2420:     Type '<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'.
+!!! error TS2420:     Type '<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }'.
 !!! error TS2420:       Type 'any[]' is not assignable to type '[any, any, any, any, any]'.
 !!! error TS2420:         Property '0' is missing in type 'any[]'.
         toString(): string;
diff --git a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt
index e1b8867d069..1f545bb01f2 100644
--- a/tests/baselines/reference/importDeclWithClassModifiers.errors.txt
+++ b/tests/baselines/reference/importDeclWithClassModifiers.errors.txt
@@ -1,11 +1,11 @@
 tests/cases/compiler/importDeclWithClassModifiers.ts(5,8): error TS1044: 'public' modifier cannot appear on a module or namespace element.
-tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithClassModifiers.ts(5,28): error TS2694: Namespace 'x' has no exported member 'c'.
 tests/cases/compiler/importDeclWithClassModifiers.ts(6,8): error TS1044: 'private' modifier cannot appear on a module or namespace element.
-tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithClassModifiers.ts(6,29): error TS2694: Namespace 'x' has no exported member 'c'.
 tests/cases/compiler/importDeclWithClassModifiers.ts(7,8): error TS1044: 'static' modifier cannot appear on a module or namespace element.
-tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no exported member 'c'.
 
 
@@ -18,21 +18,21 @@ tests/cases/compiler/importDeclWithClassModifiers.ts(7,28): error TS2694: Namesp
            ~~~~~~
 !!! error TS1044: 'public' modifier cannot appear on a module or namespace element.
                              ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                                ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     export private import b = x.c;
            ~~~~~~~
 !!! error TS1044: 'private' modifier cannot appear on a module or namespace element.
                               ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                                 ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     export static import c = x.c;
            ~~~~~~
 !!! error TS1044: 'static' modifier cannot appear on a module or namespace element.
                              ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                                ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     var b: a;
diff --git a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt
index d69a88964cc..93619813aa2 100644
--- a/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt
+++ b/tests/baselines/reference/importDeclWithDeclareModifier.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/importDeclWithDeclareModifier.ts(5,9): error TS1029: 'export' modifier must precede 'declare' modifier.
-tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithDeclareModifier.ts(5,27): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Namespace 'x' has no exported member 'c'.
 
 
@@ -12,7 +12,7 @@ tests/cases/compiler/importDeclWithDeclareModifier.ts(5,29): error TS2694: Names
             ~~~~~~
 !!! error TS1029: 'export' modifier must precede 'declare' modifier.
                               ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                                 ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     var b: a;
diff --git a/tests/baselines/reference/importDeclWithExportModifier.errors.txt b/tests/baselines/reference/importDeclWithExportModifier.errors.txt
index 56e9a159afb..2a5dbbf74ef 100644
--- a/tests/baselines/reference/importDeclWithExportModifier.errors.txt
+++ b/tests/baselines/reference/importDeclWithExportModifier.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'.
 
 
@@ -9,7 +9,7 @@ tests/cases/compiler/importDeclWithExportModifier.ts(5,21): error TS2694: Namesp
     }
     export import a = x.c;
                       ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                         ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     var b: a;
diff --git a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt
index ff3c47e9f33..f9f683c502b 100644
--- a/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt
+++ b/tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2304: Cannot find name 'x'.
+tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value.
 tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'.
 tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): error TS2309: An export assignment cannot be used in a module with other exported elements.
 
@@ -10,7 +10,7 @@ tests/cases/compiler/importDeclWithExportModifierAndExportAssignment.ts(6,1): er
     }
     export import a = x.c;
                       ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2708: Cannot use namespace 'x' as a value.
                         ~
 !!! error TS2694: Namespace 'x' has no exported member 'c'.
     export = x;
diff --git a/tests/baselines/reference/importStatementsInterfaces.errors.txt b/tests/baselines/reference/importStatementsInterfaces.errors.txt
index 313365fb191..a43c368a2c2 100644
--- a/tests/baselines/reference/importStatementsInterfaces.errors.txt
+++ b/tests/baselines/reference/importStatementsInterfaces.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2304: Cannot find name 'a'.
+tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts(23,19): error TS2708: Cannot use namespace 'a' as a value.
 
 
 ==== tests/cases/conformance/internalModules/codeGeneration/importStatementsInterfaces.ts (1 errors) ====
@@ -26,7 +26,7 @@ tests/cases/conformance/internalModules/codeGeneration/importStatementsInterface
         import b = a.inA;
         var m: typeof a;
                       ~
-!!! error TS2304: Cannot find name 'a'.
+!!! error TS2708: Cannot use namespace 'a' as a value.
         var p: b.Point3D;
         var p = {x:0, y:0, z: 0 };
     }
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index 9f2f11d988f..c7cb6d8333e 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -84,9 +84,9 @@ export class BrokenClass {
 >Promise : PromiseConstructor
 >all : { <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; }
 >result.map(populateItems) : Promise<{}>[]
->result.map : { <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; <U>(callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; }
+>result.map : { <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; <U>(callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; }
 >result : MyModule.MyModel[]
->map : { <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; <U>(callbackfn: (this: undefined, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): [U, U]; <U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U): U[]; <U>(callbackfn: (this: void, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg: Z): U[]; }
 >populateItems : (order: any) => Promise<{}>
 
       .then((orders: Array<MyModule.MyModel>) => {
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.types b/tests/baselines/reference/inferentialTypingWithFunctionType2.types
index 55caace2c2c..90c84817922 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionType2.types
+++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.types
@@ -13,12 +13,12 @@ var x = [1, 2, 3].map(identity)[0];
 >x : number
 >[1, 2, 3].map(identity)[0] : number
 >[1, 2, 3].map(identity) : number[]
->[1, 2, 3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>[1, 2, 3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >identity : <A>(a: A) => A
 >0 : 0
 
diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols
new file mode 100644
index 00000000000..2ed29dcb72d
--- /dev/null
+++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.symbols
@@ -0,0 +1,130 @@
+=== tests/cases/conformance/salsa/a.js ===
+export class C1 { }
+>C1 : Symbol(C1, Decl(a.js, 0, 0))
+
+C1.staticProp = 0;
+>C1.staticProp : Symbol(C1.staticProp, Decl(a.js, 0, 19))
+>C1 : Symbol(C1, Decl(a.js, 0, 0))
+>staticProp : Symbol(C1.staticProp, Decl(a.js, 0, 19))
+
+export function F1() { }
+>F1 : Symbol(F1, Decl(a.js, 1, 18))
+
+F1.staticProp = 0;
+>F1.staticProp : Symbol(F1.staticProp, Decl(a.js, 3, 24))
+>F1 : Symbol(F1, Decl(a.js, 1, 18))
+>staticProp : Symbol(F1.staticProp, Decl(a.js, 3, 24))
+
+export var C2 = class { };
+>C2 : Symbol(C2, Decl(a.js, 6, 10))
+
+C2.staticProp = 0;
+>C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26))
+>C2 : Symbol(C2, Decl(a.js, 6, 10))
+>staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26))
+
+export let F2 = function () { };
+>F2 : Symbol(F2, Decl(a.js, 9, 10))
+
+F2.staticProp = 0;
+>F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32))
+>F2 : Symbol(F2, Decl(a.js, 9, 10))
+>staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32))
+
+=== tests/cases/conformance/salsa/global.js ===
+class C3 { }
+>C3 : Symbol(C3, Decl(global.js, 0, 0))
+
+C3.staticProp = 0;
+>C3.staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12))
+>C3 : Symbol(C3, Decl(global.js, 0, 0))
+>staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12))
+
+function F3() { }
+>F3 : Symbol(F3, Decl(global.js, 1, 18))
+
+F3.staticProp = 0;
+>F3.staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17))
+>F3 : Symbol(F3, Decl(global.js, 1, 18))
+>staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17))
+
+var C4 = class { };
+>C4 : Symbol(C4, Decl(global.js, 6, 3))
+
+C4.staticProp = 0;
+>C4.staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19))
+>C4 : Symbol(C4, Decl(global.js, 6, 3))
+>staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19))
+
+let F4 = function () { };
+>F4 : Symbol(F4, Decl(global.js, 9, 3))
+
+F4.staticProp = 0;
+>F4.staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25))
+>F4 : Symbol(F4, Decl(global.js, 9, 3))
+>staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25))
+
+=== tests/cases/conformance/salsa/b.ts ===
+import * as a from "./a";
+>a : Symbol(a, Decl(b.ts, 0, 6))
+
+var n: number;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+
+var n = a.C1.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>a.C1.staticProp : Symbol(a.C1.staticProp, Decl(a.js, 0, 19))
+>a.C1 : Symbol(a.C1, Decl(a.js, 0, 0))
+>a : Symbol(a, Decl(b.ts, 0, 6))
+>C1 : Symbol(a.C1, Decl(a.js, 0, 0))
+>staticProp : Symbol(a.C1.staticProp, Decl(a.js, 0, 19))
+
+var n = a.C2.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>a.C2.staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26))
+>a.C2 : Symbol(a.C2, Decl(a.js, 6, 10))
+>a : Symbol(a, Decl(b.ts, 0, 6))
+>C2 : Symbol(a.C2, Decl(a.js, 6, 10))
+>staticProp : Symbol(C2.staticProp, Decl(a.js, 6, 26))
+
+var n = a.F1.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>a.F1.staticProp : Symbol(a.F1.staticProp, Decl(a.js, 3, 24))
+>a.F1 : Symbol(a.F1, Decl(a.js, 1, 18))
+>a : Symbol(a, Decl(b.ts, 0, 6))
+>F1 : Symbol(a.F1, Decl(a.js, 1, 18))
+>staticProp : Symbol(a.F1.staticProp, Decl(a.js, 3, 24))
+
+var n = a.F2.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>a.F2.staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32))
+>a.F2 : Symbol(a.F2, Decl(a.js, 9, 10))
+>a : Symbol(a, Decl(b.ts, 0, 6))
+>F2 : Symbol(a.F2, Decl(a.js, 9, 10))
+>staticProp : Symbol(F2.staticProp, Decl(a.js, 9, 32))
+
+
+var n = C3.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>C3.staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12))
+>C3 : Symbol(C3, Decl(global.js, 0, 0))
+>staticProp : Symbol(C3.staticProp, Decl(global.js, 0, 12))
+
+var n = C4.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>C4.staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19))
+>C4 : Symbol(C4, Decl(global.js, 6, 3))
+>staticProp : Symbol(C4.staticProp, Decl(global.js, 6, 19))
+
+var n = F3.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>F3.staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17))
+>F3 : Symbol(F3, Decl(global.js, 1, 18))
+>staticProp : Symbol(F3.staticProp, Decl(global.js, 3, 17))
+
+var n = F4.staticProp;
+>n : Symbol(n, Decl(b.ts, 1, 3), Decl(b.ts, 3, 3), Decl(b.ts, 4, 3), Decl(b.ts, 5, 3), Decl(b.ts, 6, 3), Decl(b.ts, 9, 3), Decl(b.ts, 10, 3), Decl(b.ts, 11, 3), Decl(b.ts, 12, 3))
+>F4.staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25))
+>F4 : Symbol(F4, Decl(global.js, 9, 3))
+>staticProp : Symbol(F4.staticProp, Decl(global.js, 9, 25))
+
diff --git a/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types
new file mode 100644
index 00000000000..69dff49724b
--- /dev/null
+++ b/tests/baselines/reference/inferringClassStaticMembersFromAssignments.types
@@ -0,0 +1,150 @@
+=== tests/cases/conformance/salsa/a.js ===
+export class C1 { }
+>C1 : C1
+
+C1.staticProp = 0;
+>C1.staticProp = 0 : 0
+>C1.staticProp : number
+>C1 : typeof C1
+>staticProp : number
+>0 : 0
+
+export function F1() { }
+>F1 : { (): void; staticProp: number; }
+
+F1.staticProp = 0;
+>F1.staticProp = 0 : 0
+>F1.staticProp : number
+>F1 : { (): void; staticProp: number; }
+>staticProp : number
+>0 : 0
+
+export var C2 = class { };
+>C2 : typeof C2
+>class { } : typeof C2
+
+C2.staticProp = 0;
+>C2.staticProp = 0 : 0
+>C2.staticProp : number
+>C2 : typeof C2
+>staticProp : number
+>0 : 0
+
+export let F2 = function () { };
+>F2 : { (): void; staticProp: number; }
+>function () { } : { (): void; staticProp: number; }
+
+F2.staticProp = 0;
+>F2.staticProp = 0 : 0
+>F2.staticProp : number
+>F2 : { (): void; staticProp: number; }
+>staticProp : number
+>0 : 0
+
+=== tests/cases/conformance/salsa/global.js ===
+class C3 { }
+>C3 : C3
+
+C3.staticProp = 0;
+>C3.staticProp = 0 : 0
+>C3.staticProp : number
+>C3 : typeof C3
+>staticProp : number
+>0 : 0
+
+function F3() { }
+>F3 : { (): void; staticProp: number; }
+
+F3.staticProp = 0;
+>F3.staticProp = 0 : 0
+>F3.staticProp : number
+>F3 : { (): void; staticProp: number; }
+>staticProp : number
+>0 : 0
+
+var C4 = class { };
+>C4 : typeof C4
+>class { } : typeof C4
+
+C4.staticProp = 0;
+>C4.staticProp = 0 : 0
+>C4.staticProp : number
+>C4 : typeof C4
+>staticProp : number
+>0 : 0
+
+let F4 = function () { };
+>F4 : { (): void; staticProp: number; }
+>function () { } : { (): void; staticProp: number; }
+
+F4.staticProp = 0;
+>F4.staticProp = 0 : 0
+>F4.staticProp : number
+>F4 : { (): void; staticProp: number; }
+>staticProp : number
+>0 : 0
+
+=== tests/cases/conformance/salsa/b.ts ===
+import * as a from "./a";
+>a : typeof a
+
+var n: number;
+>n : number
+
+var n = a.C1.staticProp;
+>n : number
+>a.C1.staticProp : number
+>a.C1 : typeof a.C1
+>a : typeof a
+>C1 : typeof a.C1
+>staticProp : number
+
+var n = a.C2.staticProp;
+>n : number
+>a.C2.staticProp : number
+>a.C2 : typeof C2
+>a : typeof a
+>C2 : typeof C2
+>staticProp : number
+
+var n = a.F1.staticProp;
+>n : number
+>a.F1.staticProp : number
+>a.F1 : { (): void; staticProp: number; }
+>a : typeof a
+>F1 : { (): void; staticProp: number; }
+>staticProp : number
+
+var n = a.F2.staticProp;
+>n : number
+>a.F2.staticProp : number
+>a.F2 : { (): void; staticProp: number; }
+>a : typeof a
+>F2 : { (): void; staticProp: number; }
+>staticProp : number
+
+
+var n = C3.staticProp;
+>n : number
+>C3.staticProp : number
+>C3 : typeof C3
+>staticProp : number
+
+var n = C4.staticProp;
+>n : number
+>C4.staticProp : number
+>C4 : typeof C4
+>staticProp : number
+
+var n = F3.staticProp;
+>n : number
+>F3.staticProp : number
+>F3 : { (): void; staticProp: number; }
+>staticProp : number
+
+var n = F4.staticProp;
+>n : number
+>F4.staticProp : number
+>F4 : { (): void; staticProp: number; }
+>staticProp : number
+
diff --git a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt
index 5be40b5b7b6..cc9cc927d0f 100644
--- a/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt
+++ b/tests/baselines/reference/interfaceNameAsIdentifier.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/interfaceNameAsIdentifier.ts(4,1): error TS2693: 'C' only refers to a type, but is being used as a value here.
-tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2304: Cannot find name 'm2'.
+tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2708: Cannot use namespace 'm2' as a value.
 
 
 ==== tests/cases/compiler/interfaceNameAsIdentifier.ts (2 errors) ====
@@ -18,5 +18,5 @@ tests/cases/compiler/interfaceNameAsIdentifier.ts(12,1): error TS2304: Cannot fi
     
     m2.C();
     ~~
-!!! error TS2304: Cannot find name 'm2'.
+!!! error TS2708: Cannot use namespace 'm2' as a value.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index 19ecac10188..a9698a47bd2 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -522,10 +522,10 @@ function pluck<T, K extends keyof T>(array: T[], key: K) {
 
     return array.map(x => x[key]);
 >array.map(x => x[key]) : T[K][]
->array.map : { <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
+>array.map : { <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
 >array : T[]
->map : { <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: undefined, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
->x => x[key] : (this: undefined, x: T) => T[K]
+>map : { <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U, U]; <U>(this: [T, T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [T, T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U, U]; <U>(this: [T, T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [T, T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U, U]; <U>(this: [T, T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [T, T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U): [U, U]; <U>(this: [T, T], callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [T, T], callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U): U[]; <U>(callbackfn: (this: void, value: T, index: number, array: T[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: T, index: number, array: T[]) => U, thisArg: Z): U[]; }
+>x => x[key] : (this: void, x: T) => T[K]
 >x : T
 >x[key] : T[K]
 >x : T
diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types
index e55edda1124..72b6a6dbae1 100644
--- a/tests/baselines/reference/mapOnTupleTypes01.types
+++ b/tests/baselines/reference/mapOnTupleTypes01.types
@@ -2,14 +2,14 @@
 export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
 >mapOnLooseArrayLiteral : number[]
 >[1, 2, 3, 4].map(n => n * n) : number[]
->[1, 2, 3, 4].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>[1, 2, 3, 4].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >[1, 2, 3, 4] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
 >4 : 4
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -25,10 +25,10 @@ let numTuple: [number] = [1];
 export let a = numTuple.map(x => x * x);
 >a : number[]
 >numTuple.map(x => x * x) : number[]
->numTuple.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numTuple.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numTuple : [number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->x => x * x : (this: undefined, x: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>x => x * x : (this: void, x: number) => number
 >x : number
 >x * x : number
 >x : number
@@ -57,10 +57,10 @@ let numStr: [number, string] = [    100, "hello"];
 export let b = numNum.map(n => n * n);
 >b : [number, number]
 >numNum.map(n => n * n) : [number, number]
->numNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numNum : [number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -69,10 +69,10 @@ export let b = numNum.map(n => n * n);
 export let c = strStr.map(s => s.charCodeAt(0));
 >c : [number, number]
 >strStr.map(s => s.charCodeAt(0)) : [number, number]
->strStr.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>strStr.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >strStr : [string, string]
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->s => s.charCodeAt(0) : (this: undefined, s: string) => number
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>s => s.charCodeAt(0) : (this: void, s: string) => number
 >s : string
 >s.charCodeAt(0) : number
 >s.charCodeAt : (index: number) => number
@@ -83,10 +83,10 @@ export let c = strStr.map(s => s.charCodeAt(0));
 export let d = numStr.map(x => x);
 >d : [string | number, string | number]
 >numStr.map(x => x) : [string | number, string | number]
->numStr.map : { <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; <U>(this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; }
+>numStr.map : { <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; <U>(this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): U[]; <U>(callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; }
 >numStr : [number, string]
->map : { <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; <U>(this: [string | number, string | number], callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; }
->x => x : (this: undefined, x: string | number) => string | number
+>map : { <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U, U]; <U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string | number, string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U, U]; <U>(this: [string | number, string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string | number, string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): [U, U]; <U>(this: [string | number, string | number], callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string | number, string | number], callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U): U[]; <U>(callbackfn: (this: void, value: string | number, index: number, array: (string | number)[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string | number, index: number, array: (string | number)[]) => U, thisArg: Z): U[]; }
+>x => x : (this: void, x: string | number) => string | number
 >x : string | number
 >x : string | number
 
@@ -102,10 +102,10 @@ let numNumNum: [number, number, number] = [1, 2, 3];
 export let e = numNumNum.map(n => n * n);
 >e : [number, number, number]
 >numNumNum.map(n => n * n) : [number, number, number]
->numNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numNumNum : [number, number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -124,10 +124,10 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
 export let f = numNumNumNum.map(n => n * n);
 >f : [number, number, number, number]
 >numNumNumNum.map(n => n * n) : [number, number, number, number]
->numNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numNumNumNum : [number, number, number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -147,10 +147,10 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
 export let g = numNumNumNumNum.map(n => n * n);
 >g : [number, number, number, number, number]
 >numNumNumNumNum.map(n => n * n) : [number, number, number, number, number]
->numNumNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numNumNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numNumNumNumNum : [number, number, number, number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -172,10 +172,10 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2
 export let h = numNumNumNumNum.map(n => n * n);
 >h : [number, number, number, number, number]
 >numNumNumNumNum.map(n => n * n) : [number, number, number, number, number]
->numNumNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>numNumNumNumNum.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >numNumNumNumNum : [number, number, number, number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->n => n * n : (this: undefined, n: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>n => n * n : (this: void, n: number) => number
 >n : number
 >n * n : number
 >n : number
diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types
index 1a354dce354..72fbbf31b11 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.types
+++ b/tests/baselines/reference/mapOnTupleTypes02.types
@@ -9,10 +9,10 @@ export function increment(point: Point) {
 
   return point.map(d => d + 1);
 >point.map(d => d + 1) : [number, number]
->point.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>point.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >point : [number, number]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->d => d + 1 : (this: undefined, d: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>d => d + 1 : (this: void, d: number) => number
 >d : number
 >d + 1 : number
 >d : number
diff --git a/tests/baselines/reference/memberScope.errors.txt b/tests/baselines/reference/memberScope.errors.txt
index 017a28d5f71..7af426828db 100644
--- a/tests/baselines/reference/memberScope.errors.txt
+++ b/tests/baselines/reference/memberScope.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/memberScope.ts(4,11): error TS2304: Cannot find name 'Basil'.
+tests/cases/compiler/memberScope.ts(4,11): error TS2708: Cannot use namespace 'Basil' as a value.
 
 
 ==== tests/cases/compiler/memberScope.ts (1 errors) ====
@@ -7,7 +7,7 @@ tests/cases/compiler/memberScope.ts(4,11): error TS2304: Cannot find name 'Basil
       export module Basil { }
       var z = Basil.Pepper;
               ~~~~~
-!!! error TS2304: Cannot find name 'Basil'.
+!!! error TS2708: Cannot use namespace 'Basil' as a value.
     }
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index 7012b25ccbd..a77fcd223f4 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
@@ -177,9 +177,9 @@ var p = new Proxy(t, {});
 // Using ES6 reflect
 Reflect.isExtensible({});
 >Reflect.isExtensible({}) : boolean
->Reflect.isExtensible : (target: any) => boolean
+>Reflect.isExtensible : (target: object) => boolean
 >Reflect : typeof Reflect
->isExtensible : (target: any) => boolean
+>isExtensible : (target: object) => boolean
 >{} : {}
 
 // Using Es6 regexp
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 781e33e850a..6d5770659de 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
@@ -177,9 +177,9 @@ var p = new Proxy(t, {});
 // Using ES6 reflect
 Reflect.isExtensible({});
 >Reflect.isExtensible({}) : boolean
->Reflect.isExtensible : (target: any) => boolean
+>Reflect.isExtensible : (target: object) => boolean
 >Reflect : typeof Reflect
->isExtensible : (target: any) => boolean
+>isExtensible : (target: object) => boolean
 >{} : {}
 
 // Using Es6 regexp
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 54c6958dccc..9ca65cb9583 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
@@ -177,9 +177,9 @@ var p = new Proxy(t, {});
 // Using ES6 reflect
 Reflect.isExtensible({});
 >Reflect.isExtensible({}) : boolean
->Reflect.isExtensible : (target: any) => boolean
+>Reflect.isExtensible : (target: object) => boolean
 >Reflect : typeof Reflect
->isExtensible : (target: any) => boolean
+>isExtensible : (target: object) => boolean
 >{} : {}
 
 // Using Es6 regexp
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
index 9dd896bc9e6..1120b471f36 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
@@ -100,9 +100,9 @@ var p = new Proxy(t, {});
 // Using ES6 reflect
 Reflect.isExtensible({});
 >Reflect.isExtensible({}) : boolean
->Reflect.isExtensible : (target: any) => boolean
+>Reflect.isExtensible : (target: object) => boolean
 >Reflect : typeof Reflect
->isExtensible : (target: any) => boolean
+>isExtensible : (target: object) => boolean
 >{} : {}
 
 // Using Es6 regexp
diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types
index c5368e33a3c..3c3905c501f 100644
--- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types
+++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types
@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
index 281faddbc52..ab24aaf12ba 100644
--- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
+++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
@@ -17,9 +17,9 @@ var p = new Proxy(t, {});
 
 Reflect.ownKeys({});
 >Reflect.ownKeys({}) : PropertyKey[]
->Reflect.ownKeys : (target: any) => PropertyKey[]
+>Reflect.ownKeys : (target: object) => PropertyKey[]
 >Reflect : typeof Reflect
->ownKeys : (target: any) => PropertyKey[]
+>ownKeys : (target: object) => PropertyKey[]
 >{} : {}
 
 function* idGen() {
diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types
index 95144f1fd7a..3d4ba12fa63 100644
--- a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types
+++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types
@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >Array : ArrayConstructor
->from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: undefined, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
 >arguments : IArguments
 }
 
diff --git a/tests/baselines/reference/moduleAsBaseType.errors.txt b/tests/baselines/reference/moduleAsBaseType.errors.txt
index ffa30ad0ab3..fd5b4f581f9 100644
--- a/tests/baselines/reference/moduleAsBaseType.errors.txt
+++ b/tests/baselines/reference/moduleAsBaseType.errors.txt
@@ -1,16 +1,16 @@
-tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2304: Cannot find name 'M'.
-tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2304: Cannot find name 'M'.
-tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2304: Cannot find name 'M'.
+tests/cases/compiler/moduleAsBaseType.ts(2,17): error TS2708: Cannot use namespace 'M' as a value.
+tests/cases/compiler/moduleAsBaseType.ts(3,21): error TS2709: Cannot use namespace 'M' as a type.
+tests/cases/compiler/moduleAsBaseType.ts(4,21): error TS2709: Cannot use namespace 'M' as a type.
 
 
 ==== tests/cases/compiler/moduleAsBaseType.ts (3 errors) ====
     module M {}
     class C extends M {}
                     ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2708: Cannot use namespace 'M' as a value.
     interface I extends M { }
                         ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2709: Cannot use namespace 'M' as a type.
     class C2 implements M { }
                         ~
-!!! error TS2304: Cannot find name 'M'.
\ No newline at end of file
+!!! error TS2709: Cannot use namespace 'M' as a type.
\ No newline at end of file
diff --git a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt
index c387f5d62f4..21abac79217 100644
--- a/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt
+++ b/tests/baselines/reference/moduleWithNoValuesAsType.errors.txt
@@ -1,20 +1,20 @@
-tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2304: Cannot find name 'A'.
-tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2304: Cannot find name 'B'.
-tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2304: Cannot find name 'C'.
+tests/cases/compiler/moduleWithNoValuesAsType.ts(2,8): error TS2709: Cannot use namespace 'A' as a type.
+tests/cases/compiler/moduleWithNoValuesAsType.ts(7,8): error TS2709: Cannot use namespace 'B' as a type.
+tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2709: Cannot use namespace 'C' as a type.
 
 
 ==== tests/cases/compiler/moduleWithNoValuesAsType.ts (3 errors) ====
     module A { }
     var a: A; // error
            ~
-!!! error TS2304: Cannot find name 'A'.
+!!! error TS2709: Cannot use namespace 'A' as a type.
     
     module B {
         interface I {}
     }
     var b: B; // error
            ~
-!!! error TS2304: Cannot find name 'B'.
+!!! error TS2709: Cannot use namespace 'B' as a type.
     
     module C {
         module M {
@@ -24,4 +24,4 @@ tests/cases/compiler/moduleWithNoValuesAsType.ts(15,8): error TS2304: Cannot fin
     
     var c: C; // error
            ~
-!!! error TS2304: Cannot find name 'C'.
\ No newline at end of file
+!!! error TS2709: Cannot use namespace 'C' as a type.
\ No newline at end of file
diff --git a/tests/baselines/reference/narrowedConstInMethod.js b/tests/baselines/reference/narrowedConstInMethod.js
index e2bd1c1cd21..e86b6df6a46 100644
--- a/tests/baselines/reference/narrowedConstInMethod.js
+++ b/tests/baselines/reference/narrowedConstInMethod.js
@@ -1,9 +1,10 @@
 //// [narrowedConstInMethod.ts]
+// Fixes #10501, possibly null 'x'
 function f() {
     const x: string | null = <any>{};
     if (x !== null) {
         return {
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
         };
     }
 }
@@ -12,17 +13,19 @@ function f2() {
     const x: string | null = <any>{};
     if (x !== null) {
         return class {
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
         };
     }
-}
+}
+
 
 //// [narrowedConstInMethod.js]
+// Fixes #10501, possibly null 'x'
 function f() {
     var x = {};
     if (x !== null) {
         return {
-            bar: function () { return x.length; } // Error: possibly null x
+            bar: function () { return x.length; } // ok
         };
     }
 }
@@ -32,7 +35,7 @@ function f2() {
         return (function () {
             function class_1() {
             }
-            class_1.prototype.bar = function () { return x.length; }; // Error: possibly null x
+            class_1.prototype.bar = function () { return x.length; }; // ok
             return class_1;
         }());
     }
diff --git a/tests/baselines/reference/narrowedConstInMethod.symbols b/tests/baselines/reference/narrowedConstInMethod.symbols
index f16837bf1bd..75f8620d19c 100644
--- a/tests/baselines/reference/narrowedConstInMethod.symbols
+++ b/tests/baselines/reference/narrowedConstInMethod.symbols
@@ -1,18 +1,19 @@
 === tests/cases/compiler/narrowedConstInMethod.ts ===
+// Fixes #10501, possibly null 'x'
 function f() {
 >f : Symbol(f, Decl(narrowedConstInMethod.ts, 0, 0))
 
     const x: string | null = <any>{};
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9))
 
     if (x !== null) {
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9))
 
         return {
-            bar() { return x.length; }  // Error: possibly null x
->bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 3, 16))
+            bar() { return x.length; }  // ok
+>bar : Symbol(bar, Decl(narrowedConstInMethod.ts, 4, 16))
 >x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 1, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 2, 9))
 >length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         };
@@ -20,21 +21,22 @@ function f() {
 }
 
 function f2() {
->f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 7, 1))
+>f2 : Symbol(f2, Decl(narrowedConstInMethod.ts, 8, 1))
 
     const x: string | null = <any>{};
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9))
 
     if (x !== null) {
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9))
 
         return class {
-            bar() { return x.length; }  // Error: possibly null x
->bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 12, 22))
+            bar() { return x.length; }  // ok
+>bar : Symbol((Anonymous class).bar, Decl(narrowedConstInMethod.ts, 13, 22))
 >x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(narrowedConstInMethod.ts, 10, 9))
+>x : Symbol(x, Decl(narrowedConstInMethod.ts, 11, 9))
 >length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         };
     }
 }
+
diff --git a/tests/baselines/reference/narrowedConstInMethod.types b/tests/baselines/reference/narrowedConstInMethod.types
index 1f3886cc588..9fa0c12473f 100644
--- a/tests/baselines/reference/narrowedConstInMethod.types
+++ b/tests/baselines/reference/narrowedConstInMethod.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/narrowedConstInMethod.ts ===
+// Fixes #10501, possibly null 'x'
 function f() {
 >f : () => { bar(): number; } | undefined
 
@@ -14,9 +15,9 @@ function f() {
 >null : null
 
         return {
->{            bar() { return x.length; }  // Error: possibly null x        } : { bar(): number; }
+>{            bar() { return x.length; }  // ok        } : { bar(): number; }
 
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
 >bar : () => number
 >x.length : number
 >x : string
@@ -41,9 +42,9 @@ function f2() {
 >null : null
 
         return class {
->class {            bar() { return x.length; }  // Error: possibly null x        } : typeof (Anonymous class)
+>class {            bar() { return x.length; }  // ok        } : typeof (Anonymous class)
 
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
 >bar : () => number
 >x.length : number
 >x : string
@@ -52,3 +53,4 @@ function f2() {
         };
     }
 }
+
diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types
index 176e0dc28d3..819a76dc380 100644
--- a/tests/baselines/reference/nestedSelf.types
+++ b/tests/baselines/reference/nestedSelf.types
@@ -12,13 +12,13 @@ module M {
    public foo() { [1,2,3].map((x) => { return this.n * x; })}
 >foo : () => void
 >[1,2,3].map((x) => { return this.n * x; }) : number[]
->[1,2,3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>[1,2,3].map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >[1,2,3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
->(x) => { return this.n * x; } : (this: undefined, x: number) => number
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>(x) => { return this.n * x; } : (this: void, x: number) => number
 >x : number
 >this.n * x : number
 >this.n : number
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
index 700a88a1dab..cee8cc24e44 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
@@ -7,10 +7,10 @@ var regexMatchList = ['', ''];
 
 regexMatchList.forEach(match => ''.replace(match, ''));
 >regexMatchList.forEach(match => ''.replace(match, '')) : void
->regexMatchList.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>regexMatchList.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
 >regexMatchList : string[]
->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
->match => ''.replace(match, '') : (this: undefined, match: string) => string
+>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>match => ''.replace(match, '') : (this: void, match: string) => string
 >match : string
 >''.replace(match, '') : string
 >''.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
diff --git a/tests/baselines/reference/objectRestForOf.types b/tests/baselines/reference/objectRestForOf.types
index b7d1d1ac7be..ba6febd69c2 100644
--- a/tests/baselines/reference/objectRestForOf.types
+++ b/tests/baselines/reference/objectRestForOf.types
@@ -36,10 +36,10 @@ for ({ x: xx, ...rrestOff } of array ) {
 for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 >norest : { x: string; y: string; }
 >array.map(a => ({ ...a, x: 'a string' })) : { x: string; y: string; }[]
->array.map : { <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; }
+>array.map : { <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; }
 >array : { x: number; y: string; }[]
->map : { <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; <U>(callbackfn: (this: undefined, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; }
->a => ({ ...a, x: 'a string' }) : (this: undefined, a: { x: number; y: string; }) => { x: string; y: string; }
+>map : { <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): [U, U]; <U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [{ x: number; y: string; }, { x: number; y: string; }], callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U): U[]; <U>(callbackfn: (this: void, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg: Z): U[]; }
+>a => ({ ...a, x: 'a string' }) : (this: void, a: { x: number; y: string; }) => { x: string; y: string; }
 >a : { x: number; y: string; }
 >({ ...a, x: 'a string' }) : { x: string; y: string; }
 >{ ...a, x: 'a string' } : { x: string; y: string; }
diff --git a/tests/baselines/reference/objectRestParameter.js b/tests/baselines/reference/objectRestParameter.js
index 14e84eddfce..a73e9b77b38 100644
--- a/tests/baselines/reference/objectRestParameter.js
+++ b/tests/baselines/reference/objectRestParameter.js
@@ -14,7 +14,11 @@ class C {
         // actually, never mind, don't clone
     }
 }
-
+function foobar({ bar={}, ...opts }: any = {}) {
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
 
 
 //// [objectRestParameter.js]
@@ -48,3 +52,9 @@ class C {
         // actually, never mind, don't clone
     }
 }
+function foobar(_a = {}) {
+    var { bar = {} } = _a, opts = __rest(_a, ["bar"]);
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
diff --git a/tests/baselines/reference/objectRestParameter.symbols b/tests/baselines/reference/objectRestParameter.symbols
index c43a8ba5a04..f629f46e8e9 100644
--- a/tests/baselines/reference/objectRestParameter.symbols
+++ b/tests/baselines/reference/objectRestParameter.symbols
@@ -64,5 +64,20 @@ class C {
         // actually, never mind, don't clone
     }
 }
+function foobar({ bar={}, ...opts }: any = {}) {
+>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1))
+>bar : Symbol(bar, Decl(objectRestParameter.ts, 15, 17))
+>opts : Symbol(opts, Decl(objectRestParameter.ts, 15, 25))
+}
+foobar();
+>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1))
 
+foobar({ baz: 'hello' });
+>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1))
+>baz : Symbol(baz, Decl(objectRestParameter.ts, 18, 8))
+
+foobar({ bar: { greeting: 'hello' } });
+>foobar : Symbol(foobar, Decl(objectRestParameter.ts, 14, 1))
+>bar : Symbol(bar, Decl(objectRestParameter.ts, 19, 8))
+>greeting : Symbol(greeting, Decl(objectRestParameter.ts, 19, 15))
 
diff --git a/tests/baselines/reference/objectRestParameter.types b/tests/baselines/reference/objectRestParameter.types
index 56e7352870f..e56e7cebfc7 100644
--- a/tests/baselines/reference/objectRestParameter.types
+++ b/tests/baselines/reference/objectRestParameter.types
@@ -75,5 +75,30 @@ class C {
         // actually, never mind, don't clone
     }
 }
+function foobar({ bar={}, ...opts }: any = {}) {
+>foobar : ({bar, ...opts}?: any) => void
+>bar : {}
+>{} : {}
+>opts : any
+>{} : {}
+}
+foobar();
+>foobar() : void
+>foobar : ({bar, ...opts}?: any) => void
 
+foobar({ baz: 'hello' });
+>foobar({ baz: 'hello' }) : void
+>foobar : ({bar, ...opts}?: any) => void
+>{ baz: 'hello' } : { baz: string; }
+>baz : string
+>'hello' : "hello"
+
+foobar({ bar: { greeting: 'hello' } });
+>foobar({ bar: { greeting: 'hello' } }) : void
+>foobar : ({bar, ...opts}?: any) => void
+>{ bar: { greeting: 'hello' } } : { bar: { greeting: string; }; }
+>bar : { greeting: string; }
+>{ greeting: 'hello' } : { greeting: string; }
+>greeting : string
+>'hello' : "hello"
 
diff --git a/tests/baselines/reference/objectRestParameterES5.js b/tests/baselines/reference/objectRestParameterES5.js
new file mode 100644
index 00000000000..d16a0c68df0
--- /dev/null
+++ b/tests/baselines/reference/objectRestParameterES5.js
@@ -0,0 +1,69 @@
+//// [objectRestParameterES5.ts]
+function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
+}
+
+declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void);
+suddenly(({ x: a, ...rest }) => rest.y);
+suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
+
+class C {
+    m({ a, ...clone }: { a: number, b: string}): void {
+        // actually, never mind, don't clone
+    }
+    set p({ a, ...clone }: { a: number, b: string}) {
+        // actually, never mind, don't clone
+    }
+}
+function foobar({ bar={}, ...opts }: any = {}) {
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
+
+
+//// [objectRestParameterES5.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;
+};
+function cloneAgain(_a) {
+    var a = _a.a, clone = __rest(_a, ["a"]);
+}
+suddenly(function (_a) {
+    var a = _a.x, rest = __rest(_a, ["x"]);
+    return rest.y;
+});
+suddenly(function (_a) {
+    if (_a === void 0) { _a = { x: { z: 1, ka: 1 }, y: 'noo' }; }
+    var _b = _a.x, _c = _b.z, z = _c === void 0 ? 12 : _c, nested = __rest(_b, ["z"]), rest = __rest(_a, ["x"]);
+    return rest.y + nested.ka;
+});
+var C = (function () {
+    function C() {
+    }
+    C.prototype.m = function (_a) {
+        var a = _a.a, clone = __rest(_a, ["a"]);
+        // actually, never mind, don't clone
+    };
+    Object.defineProperty(C.prototype, "p", {
+        set: function (_a) {
+            var a = _a.a, clone = __rest(_a, ["a"]);
+            // actually, never mind, don't clone
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return C;
+}());
+function foobar(_a) {
+    if (_a === void 0) { _a = {}; }
+    var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]);
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
diff --git a/tests/baselines/reference/objectRestParameterES5.symbols b/tests/baselines/reference/objectRestParameterES5.symbols
new file mode 100644
index 00000000000..4c6b8115169
--- /dev/null
+++ b/tests/baselines/reference/objectRestParameterES5.symbols
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/types/rest/objectRestParameterES5.ts ===
+function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
+>cloneAgain : Symbol(cloneAgain, Decl(objectRestParameterES5.ts, 0, 0))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 0, 21))
+>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 0, 24))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 0, 38))
+>b : Symbol(b, Decl(objectRestParameterES5.ts, 0, 49))
+}
+
+declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void);
+>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1))
+>f : Symbol(f, Decl(objectRestParameterES5.ts, 3, 26))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 3, 30))
+>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34))
+>z : Symbol(z, Decl(objectRestParameterES5.ts, 3, 39))
+>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42))
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+
+suddenly(({ x: a, ...rest }) => rest.y);
+>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1))
+>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 4, 11))
+>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17))
+>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 4, 17))
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+
+suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
+>suddenly : Symbol(suddenly, Decl(objectRestParameterES5.ts, 1, 1))
+>x : Symbol(x, Decl(objectRestParameterES5.ts, 3, 34))
+>z : Symbol(z, Decl(objectRestParameterES5.ts, 5, 16))
+>nested : Symbol(nested, Decl(objectRestParameterES5.ts, 5, 24))
+>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 5, 37))
+>x : Symbol(x, Decl(objectRestParameterES5.ts, 5, 51))
+>z : Symbol(z, Decl(objectRestParameterES5.ts, 5, 56))
+>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 5, 62))
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 5, 71))
+>rest.y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+>rest : Symbol(rest, Decl(objectRestParameterES5.ts, 5, 37))
+>y : Symbol(y, Decl(objectRestParameterES5.ts, 3, 48))
+>nested.ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42))
+>nested : Symbol(nested, Decl(objectRestParameterES5.ts, 5, 24))
+>ka : Symbol(ka, Decl(objectRestParameterES5.ts, 3, 42))
+
+class C {
+>C : Symbol(C, Decl(objectRestParameterES5.ts, 5, 107))
+
+    m({ a, ...clone }: { a: number, b: string}): void {
+>m : Symbol(C.m, Decl(objectRestParameterES5.ts, 7, 9))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 8, 7))
+>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 8, 10))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 8, 24))
+>b : Symbol(b, Decl(objectRestParameterES5.ts, 8, 35))
+
+        // actually, never mind, don't clone
+    }
+    set p({ a, ...clone }: { a: number, b: string}) {
+>p : Symbol(C.p, Decl(objectRestParameterES5.ts, 10, 5))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 11, 11))
+>clone : Symbol(clone, Decl(objectRestParameterES5.ts, 11, 14))
+>a : Symbol(a, Decl(objectRestParameterES5.ts, 11, 28))
+>b : Symbol(b, Decl(objectRestParameterES5.ts, 11, 39))
+
+        // actually, never mind, don't clone
+    }
+}
+function foobar({ bar={}, ...opts }: any = {}) {
+>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1))
+>bar : Symbol(bar, Decl(objectRestParameterES5.ts, 15, 17))
+>opts : Symbol(opts, Decl(objectRestParameterES5.ts, 15, 25))
+}
+foobar();
+>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1))
+
+foobar({ baz: 'hello' });
+>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1))
+>baz : Symbol(baz, Decl(objectRestParameterES5.ts, 18, 8))
+
+foobar({ bar: { greeting: 'hello' } });
+>foobar : Symbol(foobar, Decl(objectRestParameterES5.ts, 14, 1))
+>bar : Symbol(bar, Decl(objectRestParameterES5.ts, 19, 8))
+>greeting : Symbol(greeting, Decl(objectRestParameterES5.ts, 19, 15))
+
diff --git a/tests/baselines/reference/objectRestParameterES5.types b/tests/baselines/reference/objectRestParameterES5.types
new file mode 100644
index 00000000000..009d810782b
--- /dev/null
+++ b/tests/baselines/reference/objectRestParameterES5.types
@@ -0,0 +1,104 @@
+=== tests/cases/conformance/types/rest/objectRestParameterES5.ts ===
+function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
+>cloneAgain : ({a, ...clone}: { a: number; b: string; }) => void
+>a : number
+>clone : { b: string; }
+>a : number
+>b : string
+}
+
+declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void);
+>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any
+>f : (a: { x: { z: any; ka: any; }; y: string; }) => void
+>a : { x: { z: any; ka: any; }; y: string; }
+>x : { z: any; ka: any; }
+>z : any
+>ka : any
+>y : string
+
+suddenly(({ x: a, ...rest }) => rest.y);
+>suddenly(({ x: a, ...rest }) => rest.y) : any
+>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any
+>({ x: a, ...rest }) => rest.y : ({x: a, ...rest}: { x: { z: any; ka: any; }; y: string; }) => string
+>x : any
+>a : { z: any; ka: any; }
+>rest : { y: string; }
+>rest.y : string
+>rest : { y: string; }
+>y : string
+
+suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
+>suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka) : any
+>suddenly : (f: (a: { x: { z: any; ka: any; }; y: string; }) => void) => any
+>({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka : ({x: {z, ...nested}, ...rest}?: { x: { z: any; ka: any; }; y: string; }) => string
+>x : any
+>z : any
+>12 : 12
+>nested : { ka: any; }
+>rest : { y: string; }
+>{ x: { z: 1, ka: 1 }, y: 'noo' } : { x: { z: number; ka: number; }; y: string; }
+>x : { z: number; ka: number; }
+>{ z: 1, ka: 1 } : { z: number; ka: number; }
+>z : number
+>1 : 1
+>ka : number
+>1 : 1
+>y : string
+>'noo' : "noo"
+>rest.y + nested.ka : string
+>rest.y : string
+>rest : { y: string; }
+>y : string
+>nested.ka : any
+>nested : { ka: any; }
+>ka : any
+
+class C {
+>C : C
+
+    m({ a, ...clone }: { a: number, b: string}): void {
+>m : ({a, ...clone}: { a: number; b: string; }) => void
+>a : number
+>clone : { b: string; }
+>a : number
+>b : string
+
+        // actually, never mind, don't clone
+    }
+    set p({ a, ...clone }: { a: number, b: string}) {
+>p : { a: number; b: string; }
+>a : number
+>clone : { b: string; }
+>a : number
+>b : string
+
+        // actually, never mind, don't clone
+    }
+}
+function foobar({ bar={}, ...opts }: any = {}) {
+>foobar : ({bar, ...opts}?: any) => void
+>bar : {}
+>{} : {}
+>opts : any
+>{} : {}
+}
+foobar();
+>foobar() : void
+>foobar : ({bar, ...opts}?: any) => void
+
+foobar({ baz: 'hello' });
+>foobar({ baz: 'hello' }) : void
+>foobar : ({bar, ...opts}?: any) => void
+>{ baz: 'hello' } : { baz: string; }
+>baz : string
+>'hello' : "hello"
+
+foobar({ bar: { greeting: 'hello' } });
+>foobar({ bar: { greeting: 'hello' } }) : void
+>foobar : ({bar, ...opts}?: any) => void
+>{ bar: { greeting: 'hello' } } : { bar: { greeting: string; }; }
+>bar : { greeting: string; }
+>{ greeting: 'hello' } : { greeting: string; }
+>greeting : string
+>'hello' : "hello"
+
diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js
new file mode 100644
index 00000000000..e7d4a4472e8
--- /dev/null
+++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.js
@@ -0,0 +1,49 @@
+//// [parameterInitializerBeforeDestructuringEmit.ts]
+interface Foo {
+    bar?: any;
+    baz?: any;
+}
+
+function foobar({ bar = {}, ...opts }: Foo = {}) {
+    "use strict";
+    "Some other prologue";
+    opts.baz(bar);
+}
+
+class C {
+    constructor({ bar = {}, ...opts }: Foo = {}) {
+        "use strict";
+        "Some other prologue";
+        opts.baz(bar);
+    }
+}
+
+
+//// [parameterInitializerBeforeDestructuringEmit.js]
+"use strict";
+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;
+};
+function foobar(_a) {
+    "use strict";
+    "Some other prologue";
+    if (_a === void 0) { _a = {}; }
+    var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]);
+    opts.baz(bar);
+}
+var C = (function () {
+    function C(_a) {
+        "use strict";
+        "Some other prologue";
+        if (_a === void 0) { _a = {}; }
+        var _b = _a.bar, bar = _b === void 0 ? {} : _b, opts = __rest(_a, ["bar"]);
+        opts.baz(bar);
+    }
+    return C;
+}());
diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols
new file mode 100644
index 00000000000..857310bf87c
--- /dev/null
+++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.symbols
@@ -0,0 +1,44 @@
+=== tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0))
+
+    bar?: any;
+>bar : Symbol(Foo.bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 15))
+
+    baz?: any;
+>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
+}
+
+function foobar({ bar = {}, ...opts }: Foo = {}) {
+>foobar : Symbol(foobar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 3, 1))
+>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 17))
+>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 27))
+>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0))
+
+    "use strict";
+    "Some other prologue";
+    opts.baz(bar);
+>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
+>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 27))
+>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
+>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 5, 17))
+}
+
+class C {
+>C : Symbol(C, Decl(parameterInitializerBeforeDestructuringEmit.ts, 9, 1))
+
+    constructor({ bar = {}, ...opts }: Foo = {}) {
+>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 17))
+>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 27))
+>Foo : Symbol(Foo, Decl(parameterInitializerBeforeDestructuringEmit.ts, 0, 0))
+
+        "use strict";
+        "Some other prologue";
+        opts.baz(bar);
+>opts.baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
+>opts : Symbol(opts, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 27))
+>baz : Symbol(Foo.baz, Decl(parameterInitializerBeforeDestructuringEmit.ts, 1, 14))
+>bar : Symbol(bar, Decl(parameterInitializerBeforeDestructuringEmit.ts, 12, 17))
+    }
+}
+
diff --git a/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types
new file mode 100644
index 00000000000..46b5983a514
--- /dev/null
+++ b/tests/baselines/reference/parameterInitializerBeforeDestructuringEmit.types
@@ -0,0 +1,58 @@
+=== tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts ===
+interface Foo {
+>Foo : Foo
+
+    bar?: any;
+>bar : any
+
+    baz?: any;
+>baz : any
+}
+
+function foobar({ bar = {}, ...opts }: Foo = {}) {
+>foobar : ({bar, ...opts}?: Foo) => void
+>bar : any
+>{} : {}
+>opts : { baz?: any; }
+>Foo : Foo
+>{} : {}
+
+    "use strict";
+>"use strict" : "use strict"
+
+    "Some other prologue";
+>"Some other prologue" : "Some other prologue"
+
+    opts.baz(bar);
+>opts.baz(bar) : any
+>opts.baz : any
+>opts : { baz?: any; }
+>baz : any
+>bar : any
+}
+
+class C {
+>C : C
+
+    constructor({ bar = {}, ...opts }: Foo = {}) {
+>bar : any
+>{} : {}
+>opts : { baz?: any; }
+>Foo : Foo
+>{} : {}
+
+        "use strict";
+>"use strict" : "use strict"
+
+        "Some other prologue";
+>"Some other prologue" : "Some other prologue"
+
+        opts.baz(bar);
+>opts.baz(bar) : any
+>opts.baz : any
+>opts : { baz?: any; }
+>baz : any
+>bar : any
+    }
+}
+
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
index ad683ef2e15..fa6f2b27fbe 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
@@ -1,15 +1,15 @@
 === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts ===
 [].map(() => [].map(p => ({ X: p })));
 >[].map(() => [].map(p => ({ X: p }))) : { X: any; }[][]
->[].map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>[].map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >[] : undefined[]
->map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >() => [].map(p => ({ X: p })) : () => { X: any; }[]
 >[].map(p => ({ X: p })) : { X: any; }[]
->[].map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>[].map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
 >[] : undefined[]
->map : { <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: undefined, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
->p => ({ X: p }) : (this: undefined, p: any) => { X: any; }
+>map : { <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U, U]; <U>(this: [any, any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [any, any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U, U]; <U>(this: [any, any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [any, any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U, U]; <U>(this: [any, any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [any, any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U): [U, U]; <U>(this: [any, any], callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [any, any], callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U): U[]; <U>(callbackfn: (this: void, value: any, index: number, array: any[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: any, index: number, array: any[]) => U, thisArg: Z): U[]; }
+>p => ({ X: p }) : (this: void, p: any) => { X: any; }
 >p : any
 >({ X: p }) : { X: any; }
 >{ X: p } : { X: any; }
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
index 01bdfc4bda6..b7dea45c6eb 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
@@ -25,9 +25,9 @@ function foo() {
 
     series2.map(seriesExtent);
 >series2.map(seriesExtent) : any[]
->series2.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>series2.map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >series2 : number[]
->map : { <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
+>map : { <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U]; <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U]; <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U]; <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U]; <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[]; <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[]; }
 >seriesExtent : (series: any) => any
 
     return null;
@@ -38,12 +38,12 @@ function foo() {
 var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >keyExtent2 : any[]
 >series.data.map(function (d: string) { return d; }) : string[]
->series.data.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>series.data.map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
 >series.data : string[]
 >series : Series
 >data : string[]
->map : { <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
->function (d: string) { return d; } : (this: undefined, d: string) => string
+>map : { <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U]; <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U]; <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U]; <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U]; <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[]; <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[]; }
+>function (d: string) { return d; } : (this: void, d: string) => string
 >d : string
 >d : string
 
diff --git a/tests/baselines/reference/targetTypeArgs.types b/tests/baselines/reference/targetTypeArgs.types
index e1bcb00ba15..ae09b5185a9 100644
--- a/tests/baselines/reference/targetTypeArgs.types
+++ b/tests/baselines/reference/targetTypeArgs.types
@@ -19,11 +19,11 @@ foo(function(x) { x });
 
 [1].forEach(function(v,i,a) { v });
 >[1].forEach(function(v,i,a) { v }) : void
->[1].forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
+>[1].forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
 >[1] : number[]
 >1 : 1
->forEach : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
->function(v,i,a) { v } : (this: undefined, v: number, i: number, a: number[]) => void
+>forEach : { (callbackfn: (this: void, value: number, index: number, array: number[]) => void): void; (callbackfn: (this: void, value: number, index: number, array: number[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => void, thisArg: Z): void; }
+>function(v,i,a) { v } : (this: void, v: number, i: number, a: number[]) => void
 >v : number
 >i : number
 >a : number[]
@@ -31,11 +31,11 @@ foo(function(x) { x });
 
 ["hello"].every(function(v,i,a) {return true;});
 >["hello"].every(function(v,i,a) {return true;}) : boolean
->["hello"].every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
+>["hello"].every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
 >["hello"] : string[]
 >"hello" : "hello"
->every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
->function(v,i,a) {return true;} : (this: undefined, v: string, i: number, a: string[]) => true
+>every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
+>function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true
 >v : string
 >i : number
 >a : string[]
@@ -43,11 +43,11 @@ foo(function(x) { x });
 
 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
->[1].every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>[1].every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
 >[1] : number[]
 >1 : 1
->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
->function(v,i,a) {return true;} : (this: undefined, v: number, i: number, a: number[]) => true
+>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true
 >v : number
 >i : number
 >a : number[]
@@ -55,11 +55,11 @@ foo(function(x) { x });
 
 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
->[1].every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>[1].every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
 >[1] : number[]
 >1 : 1
->every : { (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: undefined, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
->function(v,i,a) {return true;} : (this: undefined, v: number, i: number, a: number[]) => true
+>every : { (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean): boolean; (callbackfn: (this: void, value: number, index: number, array: number[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: number, index: number, array: number[]) => boolean, thisArg: Z): boolean; }
+>function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true
 >v : number
 >i : number
 >a : number[]
@@ -67,11 +67,11 @@ foo(function(x) { x });
 
 ["s"].every(function(v,i,a) {return true;});
 >["s"].every(function(v,i,a) {return true;}) : boolean
->["s"].every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
+>["s"].every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
 >["s"] : string[]
 >"s" : "s"
->every : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
->function(v,i,a) {return true;} : (this: undefined, v: string, i: number, a: string[]) => true
+>every : { (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean): boolean; (callbackfn: (this: void, value: string, index: number, array: string[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => boolean, thisArg: Z): boolean; }
+>function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true
 >v : string
 >i : number
 >a : string[]
@@ -79,11 +79,11 @@ foo(function(x) { x });
 
 ["s"].forEach(function(v,i,a) { v });
 >["s"].forEach(function(v,i,a) { v }) : void
->["s"].forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>["s"].forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
 >["s"] : string[]
 >"s" : "s"
->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
->function(v,i,a) { v } : (this: undefined, v: string, i: number, a: string[]) => void
+>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>function(v,i,a) { v } : (this: void, v: string, i: number, a: string[]) => void
 >v : string
 >i : number
 >a : string[]
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.types b/tests/baselines/reference/targetTypeObjectLiteralToAny.types
index 1364a5b2a23..b8802638728 100644
--- a/tests/baselines/reference/targetTypeObjectLiteralToAny.types
+++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.types
@@ -10,10 +10,10 @@ function suggest(){
 					
 	TypeScriptKeywords.forEach(function(keyword) {						
 >TypeScriptKeywords.forEach(function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	}) : void
->TypeScriptKeywords.forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>TypeScriptKeywords.forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
 >TypeScriptKeywords : string[]
->forEach : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
->function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : (this: undefined, keyword: string) => void
+>forEach : { (callbackfn: (this: void, value: string, index: number, array: string[]) => void): void; (callbackfn: (this: void, value: string, index: number, array: string[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => void, thisArg: Z): void; }
+>function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : (this: void, keyword: string) => void
 >keyword : string
 
 		result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any
diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt
new file mode 100644
index 00000000000..817478aa68e
--- /dev/null
+++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt
@@ -0,0 +1,409 @@
+tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(17,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(20,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts(23,31): error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+
+
+==== tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts (3 errors) ====
+    class A {
+        options: string[];
+    
+        addOptions(options: string[]) {
+            if (!this.options) {
+                this.options = [];
+            }
+            options.forEach(function (item) {
+                this.options.push(item);
+            }, this);
+            return this;
+        }
+    
+        testUndefined(options: string[]) {
+            const undefinedArr: Array<undefined> = []
+            options.forEach(function () {
+                undefinedArr.push(this);
+                                  ~~~~
+!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+            }); // case1
+            options.forEach(function () {
+                undefinedArr.push(this);
+                                  ~~~~
+!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+            }, undefined); // case2
+            options.forEach(function () {
+                undefinedArr.push(this);
+                                  ~~~~
+!!! error TS2345: Argument of type 'void' is not assignable to parameter of type 'undefined'.
+            }, null); // case3
+    
+            const arrLike = {} as ArrayLike<number>
+            Array.from(arrLike, function (item) {
+                return this === undefined ? 2 : 1;
+            }, undefined)
+    
+            const iterLike = [] as Iterable<number>
+            Array.from(iterLike, function (item) {
+                return this === undefined ? 2 : 1;
+            }, undefined)
+        }
+    
+        test(options: string[]) {
+            const thisObject = {
+                options: [] as string[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            const arrLike = {} as ArrayLike<number>
+            Array.from(arrLike, function (item) {
+                return this.options[item].length
+            }, thisObject)
+    
+            const iterLike = [] as Iterable<number>
+            Array.from(iterLike, function (item) {
+                return this.options[item].length
+            }, thisObject)
+        }
+    
+        test1(options: string[]) {
+            const thisObject = {
+                options: [] as ReadonlyArray<string>
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test2(options: Int8Array[]) {
+            const thisObject = {
+                options: [] as Int8Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test3(options: Uint8Array[]) {
+            const thisObject = {
+                options: [] as Uint8Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test4(options: Float32Array[]) {
+            const thisObject = {
+                options: [] as Float32Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test5(options: Uint8ClampedArray[]) {
+            const thisObject = {
+                options: [] as Uint8ClampedArray[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test6(options: Int16Array[]) {
+            const thisObject = {
+                options: [] as Int16Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test7(options: Uint16Array[]) {
+            const thisObject = {
+                options: [] as Uint16Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test8(options: Uint32Array[]) {
+            const thisObject = {
+                options: [] as Uint32Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    
+        test9(options: Float64Array[]) {
+            const thisObject = {
+                options: [] as Float64Array[]
+            };
+    
+            options.find(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.findIndex(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.forEach(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.map(function (val, index) {
+                if (val === this.options[index])
+                    return this.options[index];
+            }, thisObject);
+    
+            options.some(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.filter(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+    
+            options.every(function (val, index) {
+                return val === this.options[index];
+            }, thisObject);
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxSpreadChildren.types b/tests/baselines/reference/tsxSpreadChildren.types
index dcdd0cd7137..7f4609c30b8 100644
--- a/tests/baselines/reference/tsxSpreadChildren.types
+++ b/tests/baselines/reference/tsxSpreadChildren.types
@@ -63,10 +63,10 @@ function TodoList({ todos }: TodoListProps) {
 
         {...todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>)}
 >todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>) : JSX.Element[]
->todos.map : { <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; }
+>todos.map : { <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; <U>(callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; }
 >todos : TodoProp[]
->map : { <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; }
->todo => <Todo key={todo.id} todo={todo.todo}/> : (this: undefined, todo: TodoProp) => JSX.Element
+>map : { <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U, U]; <U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TodoProp, TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): [U, U]; <U>(this: [TodoProp, TodoProp], callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TodoProp, TodoProp], callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U): U[]; <U>(callbackfn: (this: void, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TodoProp, index: number, array: TodoProp[]) => U, thisArg: Z): U[]; }
+>todo => <Todo key={todo.id} todo={todo.todo}/> : (this: void, todo: TodoProp) => JSX.Element
 >todo : TodoProp
 ><Todo key={todo.id} todo={todo.todo}/> : JSX.Element
 >Todo : (prop: { key: number; todo: string; }) => JSX.Element
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
index 21332704326..518bf14d010 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
@@ -16,10 +16,10 @@ var nodes: TreeNode[];
 
 nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
->nodes.map : { <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; }
+>nodes.map : { <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; <U>(callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; }
 >nodes : TreeNode[]
->map : { <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; }
->n => n.name : (this: undefined, n: TreeNode) => string
+>map : { <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U, U]; <U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNode, TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): [U, U]; <U>(this: [TreeNode, TreeNode], callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNode, TreeNode], callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U): U[]; <U>(callbackfn: (this: void, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNode, index: number, array: TreeNode[]) => U, thisArg: Z): U[]; }
+>n => n.name : (this: void, n: TreeNode) => string
 >n : TreeNode
 >n.name : string
 >n : TreeNode
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
index 6cb4b81e0ce..45054ed6aa0 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
@@ -27,10 +27,10 @@ var nodes: TreeNodeMiddleman[];
 
 nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
->nodes.map : { <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; }
+>nodes.map : { <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; <U>(callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; }
 >nodes : TreeNodeMiddleman[]
->map : { <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; <U>(callbackfn: (this: undefined, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; }
->n => n.name : (this: undefined, n: TreeNodeMiddleman) => string
+>map : { <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): [U, U]; <U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [TreeNodeMiddleman, TreeNodeMiddleman], callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U): U[]; <U>(callbackfn: (this: void, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg: Z): U[]; }
+>n => n.name : (this: void, n: TreeNodeMiddleman) => string
 >n : TreeNodeMiddleman
 >n.name : string
 >n : TreeNodeMiddleman
diff --git a/tests/baselines/reference/typeUsedAsValueError2.errors.txt b/tests/baselines/reference/typeUsedAsValueError2.errors.txt
index 3027abb0e6b..4aac95faa25 100644
--- a/tests/baselines/reference/typeUsedAsValueError2.errors.txt
+++ b/tests/baselines/reference/typeUsedAsValueError2.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/world.ts(4,1): error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here.
-tests/cases/compiler/world.ts(5,1): error TS2304: Cannot find name 'HelloNamespace'.
+tests/cases/compiler/world.ts(5,1): error TS2708: Cannot use namespace 'HelloNamespace' as a value.
 
 
 ==== tests/cases/compiler/world.ts (2 errors) ====
@@ -11,7 +11,7 @@ tests/cases/compiler/world.ts(5,1): error TS2304: Cannot find name 'HelloNamespa
 !!! error TS2693: 'HelloInterface' only refers to a type, but is being used as a value here.
     HelloNamespace.world;
     ~~~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'HelloNamespace'.
+!!! error TS2708: Cannot use namespace 'HelloNamespace' as a value.
 ==== tests/cases/compiler/helloInterface.ts (0 errors) ====
     interface HelloInterface {
         world: any;
diff --git a/tests/baselines/reference/typedArrays.types b/tests/baselines/reference/typedArrays.types
index 2446fb1e2d9..259d601d426 100644
--- a/tests/baselines/reference/typedArrays.types
+++ b/tests/baselines/reference/typedArrays.types
@@ -273,9 +273,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >obj : number[]
 
     typedArrays[1] = Uint8Array.from(obj);
@@ -284,9 +284,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >obj : number[]
 
     typedArrays[2] = Int16Array.from(obj);
@@ -295,9 +295,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >obj : number[]
 
     typedArrays[3] = Uint16Array.from(obj);
@@ -306,9 +306,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >obj : number[]
 
     typedArrays[4] = Int32Array.from(obj);
@@ -317,9 +317,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >obj : number[]
 
     typedArrays[5] = Uint32Array.from(obj);
@@ -328,9 +328,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >obj : number[]
 
     typedArrays[6] = Float32Array.from(obj);
@@ -339,9 +339,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >obj : number[]
 
     typedArrays[7] = Float64Array.from(obj);
@@ -350,9 +350,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >obj : number[]
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
@@ -361,9 +361,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >obj : number[]
 
     return typedArrays;
@@ -385,9 +385,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >obj : ArrayLike<number>
 
     typedArrays[1] = Uint8Array.from(obj);
@@ -396,9 +396,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >obj : ArrayLike<number>
 
     typedArrays[2] = Int16Array.from(obj);
@@ -407,9 +407,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >obj : ArrayLike<number>
 
     typedArrays[3] = Uint16Array.from(obj);
@@ -418,9 +418,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >obj : ArrayLike<number>
 
     typedArrays[4] = Int32Array.from(obj);
@@ -429,9 +429,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[5] = Uint32Array.from(obj);
@@ -440,9 +440,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[6] = Float32Array.from(obj);
@@ -451,9 +451,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[7] = Float64Array.from(obj);
@@ -462,9 +462,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >obj : ArrayLike<number>
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
@@ -473,9 +473,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 
     return typedArrays;
@@ -757,9 +757,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj, mapFn) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -769,9 +769,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj, mapFn) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -781,9 +781,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj, mapFn) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -793,9 +793,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj, mapFn) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -805,9 +805,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj, mapFn) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -817,9 +817,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj, mapFn) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -829,9 +829,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj, mapFn) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -841,9 +841,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj, mapFn) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -853,9 +853,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj, mapFn) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -882,9 +882,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj, mapFn, thisArg) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: ArrayLike<number>): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -895,9 +895,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj, mapFn, thisArg) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: ArrayLike<number>): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -908,9 +908,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj, mapFn, thisArg) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: ArrayLike<number>): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -921,9 +921,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj, mapFn, thisArg) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: ArrayLike<number>): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -934,9 +934,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj, mapFn, thisArg) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: ArrayLike<number>): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -947,9 +947,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj, mapFn, thisArg) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: ArrayLike<number>): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -960,9 +960,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj, mapFn, thisArg) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: ArrayLike<number>): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -973,9 +973,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj, mapFn, thisArg) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: ArrayLike<number>): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -986,9 +986,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj, mapFn, thisArg) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: undefined, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: ArrayLike<number>): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
diff --git a/tests/baselines/reference/typeofInternalModules.errors.txt b/tests/baselines/reference/typeofInternalModules.errors.txt
index c98456c3404..5402249ea63 100644
--- a/tests/baselines/reference/typeofInternalModules.errors.txt
+++ b/tests/baselines/reference/typeofInternalModules.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2304: Cannot find name 'importUninst'.
+tests/cases/compiler/typeofInternalModules.ts(15,16): error TS2708: Cannot use namespace 'importUninst' as a value.
 tests/cases/compiler/typeofInternalModules.ts(17,9): error TS2304: Cannot find name 'Outer'.
 tests/cases/compiler/typeofInternalModules.ts(19,1): error TS2322: Type 'typeof Outer' is not assignable to type 'typeof instantiated'.
   Property 'C' is missing in type 'typeof Outer'.
-tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2304: Cannot find name 'importUninst'.
+tests/cases/compiler/typeofInternalModules.ts(21,16): error TS2708: Cannot use namespace 'importUninst' as a value.
 tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof instantiated' is not assignable to type 'typeof Outer'.
   Property 'instantiated' is missing in type 'typeof instantiated'.
 
@@ -24,7 +24,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof
     var x2: importInst.C = new x1();
     var x3: typeof importUninst.P; // Error again
                    ~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'importUninst'.
+!!! error TS2708: Cannot use namespace 'importUninst' as a value.
     
     var x4: Outer = Outer;
             ~~~~~
@@ -37,7 +37,7 @@ tests/cases/compiler/typeofInternalModules.ts(23,1): error TS2322: Type 'typeof
     x5 = Outer.instantiated;
     var x6: typeof importUninst;
                    ~~~~~~~~~~~~
-!!! error TS2304: Cannot find name 'importUninst'.
+!!! error TS2708: Cannot use namespace 'importUninst' as a value.
     var x7: typeof Outer = Outer;
     x7 = importInst;
     ~~
diff --git a/tests/cases/compiler/anonymousClassExpression2.ts b/tests/cases/compiler/anonymousClassExpression2.ts
new file mode 100644
index 00000000000..85095f6a8da
--- /dev/null
+++ b/tests/cases/compiler/anonymousClassExpression2.ts
@@ -0,0 +1,17 @@
+// Fixes #14860
+// note: repros with `while (0);` too
+// but it's less inscrutable and more obvious to put it *inside* the loop
+while (0) {
+    class A {
+        methodA() {
+            this; //note: a this reference of some kind is required to trigger the bug
+        }
+    }
+
+    class B {
+        methodB() {
+            this.methodA; // error
+            this.methodB; // ok
+        }
+    }
+}
diff --git a/tests/cases/compiler/emitDecoratorMetadata_object.ts b/tests/cases/compiler/emitDecoratorMetadata_object.ts
new file mode 100644
index 00000000000..d1bdc0c7c6b
--- /dev/null
+++ b/tests/cases/compiler/emitDecoratorMetadata_object.ts
@@ -0,0 +1,13 @@
+// @experimentaldecorators: true
+// @emitdecoratormetadata: true
+// @target: ES5
+
+declare const MyClassDecorator: ClassDecorator;
+declare const MyMethodDecorator: MethodDecorator;
+
+@MyClassDecorator
+class A {
+    constructor(hi: object) {}
+    @MyMethodDecorator
+    method(there: object) {}
+}
diff --git a/tests/cases/compiler/narrowedConstInMethod.ts b/tests/cases/compiler/narrowedConstInMethod.ts
index 3ddf97a8df3..14bac690a64 100644
--- a/tests/cases/compiler/narrowedConstInMethod.ts
+++ b/tests/cases/compiler/narrowedConstInMethod.ts
@@ -1,10 +1,11 @@
 // @strictNullChecks: true
 
+// Fixes #10501, possibly null 'x'
 function f() {
     const x: string | null = <any>{};
     if (x !== null) {
         return {
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
         };
     }
 }
@@ -13,7 +14,7 @@ function f2() {
     const x: string | null = <any>{};
     if (x !== null) {
         return class {
-            bar() { return x.length; }  // Error: possibly null x
+            bar() { return x.length; }  // ok
         };
     }
-}
\ No newline at end of file
+}
diff --git a/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts b/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts
new file mode 100644
index 00000000000..461ab1b9cf8
--- /dev/null
+++ b/tests/cases/compiler/parameterInitializerBeforeDestructuringEmit.ts
@@ -0,0 +1,20 @@
+// @noImplicitUseStrict: false
+// @alwaysStrict: true
+interface Foo {
+    bar?: any;
+    baz?: any;
+}
+
+function foobar({ bar = {}, ...opts }: Foo = {}) {
+    "use strict";
+    "Some other prologue";
+    opts.baz(bar);
+}
+
+class C {
+    constructor({ bar = {}, ...opts }: Foo = {}) {
+        "use strict";
+        "Some other prologue";
+        opts.baz(bar);
+    }
+}
diff --git a/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts b/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts
new file mode 100644
index 00000000000..7ed3a81dcfe
--- /dev/null
+++ b/tests/cases/conformance/salsa/inferringClassStaticMembersFromAssignments.ts
@@ -0,0 +1,43 @@
+// @noEmit: true
+// @allowJs: true
+
+// @filename: a.js
+export class C1 { }
+C1.staticProp = 0;
+
+export function F1() { }
+F1.staticProp = 0;
+
+export var C2 = class { };
+C2.staticProp = 0;
+
+export let F2 = function () { };
+F2.staticProp = 0;
+
+//@filename: global.js
+class C3 { }
+C3.staticProp = 0;
+
+function F3() { }
+F3.staticProp = 0;
+
+var C4 = class { };
+C4.staticProp = 0;
+
+let F4 = function () { };
+F4.staticProp = 0;
+
+// @filename: b.ts
+import * as a from "./a";
+var n: number;
+
+var n = a.C1.staticProp;
+var n = a.C2.staticProp;
+var n = a.F1.staticProp;
+var n = a.F2.staticProp;
+
+
+var n = C3.staticProp;
+var n = C4.staticProp;
+var n = F3.staticProp;
+var n = F4.staticProp;
\ No newline at end of file
diff --git a/tests/cases/conformance/types/rest/objectRestParameter.ts b/tests/cases/conformance/types/rest/objectRestParameter.ts
index a9c17a29d14..5b6faeb7978 100644
--- a/tests/cases/conformance/types/rest/objectRestParameter.ts
+++ b/tests/cases/conformance/types/rest/objectRestParameter.ts
@@ -14,4 +14,8 @@ class C {
         // actually, never mind, don't clone
     }
 }
-
+function foobar({ bar={}, ...opts }: any = {}) {
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
diff --git a/tests/cases/conformance/types/rest/objectRestParameterES5.ts b/tests/cases/conformance/types/rest/objectRestParameterES5.ts
new file mode 100644
index 00000000000..07a15ffbd44
--- /dev/null
+++ b/tests/cases/conformance/types/rest/objectRestParameterES5.ts
@@ -0,0 +1,21 @@
+// @target: es5
+function cloneAgain({ a, ...clone }: { a: number, b: string }): void {
+}
+
+declare function suddenly(f: (a: { x: { z, ka }, y: string }) => void);
+suddenly(({ x: a, ...rest }) => rest.y);
+suddenly(({ x: { z = 12, ...nested }, ...rest } = { x: { z: 1, ka: 1 }, y: 'noo' }) => rest.y + nested.ka);
+
+class C {
+    m({ a, ...clone }: { a: number, b: string}): void {
+        // actually, never mind, don't clone
+    }
+    set p({ a, ...clone }: { a: number, b: string}) {
+        // actually, never mind, don't clone
+    }
+}
+function foobar({ bar={}, ...opts }: any = {}) {
+}
+foobar();
+foobar({ baz: 'hello' });
+foobar({ bar: { greeting: 'hello' } });
diff --git a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts
index 06bc6e94782..3f325a546c2 100644
--- a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts
+++ b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts
@@ -11,11 +11,6 @@
 
 const ranges = test.ranges();
 const [r0, r1] = ranges;
-verify.referenceGroups(r0, [
-    { definition: "import x", ranges: [r0] },
-    { definition: 'module "jquery"', ranges: [r1] }
-]);
-verify.referenceGroups(r1, [
-    { definition: 'module "jquery"', ranges: [r0] },
-    { definition: "import x", ranges: [r1] }
-]);
+// TODO: Want these to be in the same group, but that would require creating a symbol for `x`.
+verify.singleReferenceGroup("import x", [r0]);
+verify.singleReferenceGroup("import x", [r1]);
\ No newline at end of file
diff --git a/tests/cases/fourslash/ambientVariablesWithSameName.ts b/tests/cases/fourslash/ambientVariablesWithSameName.ts
index 45020cc2c32..30e8889875d 100644
--- a/tests/cases/fourslash/ambientVariablesWithSameName.ts
+++ b/tests/cases/fourslash/ambientVariablesWithSameName.ts
@@ -7,4 +7,4 @@
 
 goTo.eof();
 edit.insertLine('');
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
diff --git a/tests/cases/fourslash/cloduleAsBaseClass.ts b/tests/cases/fourslash/cloduleAsBaseClass.ts
index 89f7b8ce8a7..96b258aed44 100644
--- a/tests/cases/fourslash/cloduleAsBaseClass.ts
+++ b/tests/cases/fourslash/cloduleAsBaseClass.ts
@@ -42,4 +42,4 @@ verify.completionListContains('baz');
 verify.completionListContains('x');
 edit.insert('bar()');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/cloduleAsBaseClass2.ts b/tests/cases/fourslash/cloduleAsBaseClass2.ts
index 995348fc7d1..d81c4a8c11b 100644
--- a/tests/cases/fourslash/cloduleAsBaseClass2.ts
+++ b/tests/cases/fourslash/cloduleAsBaseClass2.ts
@@ -46,4 +46,4 @@ verify.completionListContains('baz');
 verify.completionListContains('x');
 edit.insert('bar()');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
diff --git a/tests/cases/fourslash/cloduleTypeOf1.ts b/tests/cases/fourslash/cloduleTypeOf1.ts
index 31394342110..189a0664ef3 100644
--- a/tests/cases/fourslash/cloduleTypeOf1.ts
+++ b/tests/cases/fourslash/cloduleTypeOf1.ts
@@ -30,4 +30,4 @@ edit.insert('x;');
 
 verify.quickInfoAt("5", "(local var) r2: number");
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/cloduleWithRecursiveReference.ts b/tests/cases/fourslash/cloduleWithRecursiveReference.ts
index 41b12581ecc..a0fb69040ff 100644
--- a/tests/cases/fourslash/cloduleWithRecursiveReference.ts
+++ b/tests/cases/fourslash/cloduleWithRecursiveReference.ts
@@ -10,4 +10,4 @@
 ////}
 
 verify.quickInfoAt("", "var M.C.C: typeof M.C");
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionEntryForUnionMethod.ts b/tests/cases/fourslash/completionEntryForUnionMethod.ts
index 2dc80e757b2..8c112a6d52e 100644
--- a/tests/cases/fourslash/completionEntryForUnionMethod.ts
+++ b/tests/cases/fourslash/completionEntryForUnionMethod.ts
@@ -5,7 +5,7 @@
 
 goTo.marker();
 verify.quickInfoIs(
-    "(property) map: {\n    <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n    <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U];\n    <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[];\n    <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n    <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n    <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U];\n    <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[];\n    <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}",
+    "(property) map: {\n    <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n    <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U];\n    <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[];\n    <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n    <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n    <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U];\n    <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[];\n    <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}",
     "Calls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.");
 
-verify.completionListContains('map', "(property) map: {\n    <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n    <U>(this: [string, string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): [U, U];\n    <U>(this: [string, string], callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U): U[];\n    <U>(callbackfn: (this: undefined, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n    <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n    <U>(this: [number, number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): [U, U];\n    <U>(this: [number, number], callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U): U[];\n    <U>(callbackfn: (this: undefined, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}");
+verify.completionListContains('map', "(property) map: {\n    <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U, U];\n    <U>(this: [string, string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [string, string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U, U];\n    <U>(this: [string, string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [string, string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U, U];\n    <U>(this: [string, string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [string, string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U): [U, U];\n    <U>(this: [string, string], callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [string, string], callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U): U[];\n    <U>(callbackfn: (this: void, value: string, index: number, array: string[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: string, index: number, array: string[]) => U, thisArg: Z): U[];\n} | {\n    <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U, U];\n    <U>(this: [number, number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U, U];\n    <Z, U>(this: [number, number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U, U];\n    <U>(this: [number, number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U, U];\n    <Z, U>(this: [number, number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U, U];\n    <U>(this: [number, number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U, U];\n    <Z, U>(this: [number, number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U, U];\n    <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U): [U, U];\n    <U>(this: [number, number], callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): [U, U];\n    <Z, U>(this: [number, number], callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): [U, U];\n    <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U): U[];\n    <U>(callbackfn: (this: void, value: number, index: number, array: number[]) => U, thisArg: undefined): U[];\n    <Z, U>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg: Z): U[];\n}");
diff --git a/tests/cases/fourslash/completionListInImportClause04.ts b/tests/cases/fourslash/completionListInImportClause04.ts
index fa49b57c8d7..60ec5790120 100644
--- a/tests/cases/fourslash/completionListInImportClause04.ts
+++ b/tests/cases/fourslash/completionListInImportClause04.ts
@@ -12,6 +12,6 @@
 ////import {/*1*/} from './foo';
 
 verify.completionsAt("1", ["prototype", "prop1", "prop2"]);
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('2');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts
index b46beb8cd53..26c9ca3b096 100644
--- a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts
+++ b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses.ts
@@ -32,4 +32,4 @@ verify.not.completionListContains('bar');
 verify.not.completionListContains('baz');
 edit.insert('foo;');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts
index f893619244a..73aae2e3596 100644
--- a/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts
+++ b/tests/cases/fourslash/completionListsThroughTransitiveBaseClasses2.ts
@@ -35,4 +35,4 @@ verify.not.completionListContains('bar');
 verify.not.completionListContains('baz');
 edit.insert('foo;');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts b/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts
index ad8bbfe6a7f..21489b5d8aa 100644
--- a/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts
+++ b/tests/cases/fourslash/derivedTypeIndexerWithGenericConstraints.ts
@@ -25,4 +25,4 @@
 ////var result2 = r2.x;
 
 verify.quickInfoAt("", "var r: CollectionItem");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts b/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts
index d83d71efa9c..b462e906166 100644
--- a/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts
+++ b/tests/cases/fourslash/editLambdaArgToTypeParameter1.ts
@@ -10,8 +10,8 @@
 goTo.marker('1');
 edit.backspace(6);
 edit.insert('T');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 goTo.marker('2');
 edit.insertLine('');
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/enumUpdate1.ts b/tests/cases/fourslash/enumUpdate1.ts
index e7ccfdb5f83..2616396344b 100644
--- a/tests/cases/fourslash/enumUpdate1.ts
+++ b/tests/cases/fourslash/enumUpdate1.ts
@@ -19,7 +19,7 @@
 // If we do not, an error will be raised claiming
 // that foo's return type is not assignable with
 // it's signature return type
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insert('D = C << 1,');
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts b/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts
index b98eec4eaf4..2cd351635b3 100644
--- a/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts
+++ b/tests/cases/fourslash/errorsAfterResolvingVariableDeclOfMergedVariableAndClassDecl.ts
@@ -10,7 +10,7 @@
 ////    }
 ////}
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 // Edit and bind and resolve only var decl
 goTo.marker("1");
@@ -18,5 +18,4 @@ edit.backspace(1);
 edit.insert(" ");
 verify.quickInfoIs("var M.C.C: typeof M.C");
 
-// Verify there are no errors
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/exportEqualTypes.ts b/tests/cases/fourslash/exportEqualTypes.ts
index b03e21b5f99..f130d211031 100644
--- a/tests/cases/fourslash/exportEqualTypes.ts
+++ b/tests/cases/fourslash/exportEqualTypes.ts
@@ -21,4 +21,4 @@ verify.quickInfos({
 });
 goTo.marker('4');
 verify.completionListContains('foo');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/extendArrayInterfaceMember.ts b/tests/cases/fourslash/extendArrayInterfaceMember.ts
index 22aeed01f1d..6c026e8d0d9 100644
--- a/tests/cases/fourslash/extendArrayInterfaceMember.ts
+++ b/tests/cases/fourslash/extendArrayInterfaceMember.ts
@@ -17,4 +17,4 @@ edit.insert("interface Array<T> { pop(def: T): T; }");
 
 verify.not.errorExistsBetweenMarkers("1", "2");
 verify.quickInfoAt("y", "var y: number");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts b/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts
index 0ef8942cded..dd4332c2473 100644
--- a/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts
+++ b/tests/cases/fourslash/extendInterfaceOverloadedMethod.ts
@@ -12,4 +12,4 @@
 ////var /**/x = b.foo2().foo(5).foo(); // 'x' is of type 'void'
 
 verify.quickInfoAt("", "var x: void");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/extendsTArray.ts b/tests/cases/fourslash/extendsTArray.ts
index 24482125ca8..8f655b9db45 100644
--- a/tests/cases/fourslash/extendsTArray.ts
+++ b/tests/cases/fourslash/extendsTArray.ts
@@ -11,4 +11,4 @@
 ////y.length;
 
 verify.quickInfoAt("", "var y: Date[]");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/findAllReferencesOfConstructor.ts b/tests/cases/fourslash/findAllReferencesOfConstructor.ts
index dcdc23bdc7f..37f0264c816 100644
--- a/tests/cases/fourslash/findAllReferencesOfConstructor.ts
+++ b/tests/cases/fourslash/findAllReferencesOfConstructor.ts
@@ -41,6 +41,14 @@
 ////class d extends a.C { constructor() { [|super|](); }
 
 const ranges = test.ranges();
-const [r0, r1, r2] = ranges;
-verify.referenceGroups([r0, r2], [{ definition: "constructor C(n: number): C (+1 overload)", ranges }]);
-verify.referenceGroups(r1, [{ definition: "constructor C(): C (+1 overload)", ranges }]);
+const [a0, a1, a2, a3, a4, b0, c0, d0, d1] = ranges;
+verify.referenceGroups([a0, a2], defs("constructor C(n: number): C (+1 overload)"));
+verify.referenceGroups(a1, defs("constructor C(): C (+1 overload)"));
+
+function defs(definition: string) {
+    return [
+        { definition, ranges: [a0, a1, a2, a3, d0, d1, a4] },
+        { definition: "import C", ranges: [b0] },
+        { definition: "import C", ranges: [c0] }
+    ]
+}
diff --git a/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts
new file mode 100644
index 00000000000..e5f77631324
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsDefaultImportThroughNamespace.ts
@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////export default function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {}
+
+// @Filename: /b.ts
+////export import a = require("./a");
+
+// @Filename: /c.ts
+////import { a } from "./b";
+////a.[|default|]();
+////
+////declare const x: { [|{| "isWriteAccess": true, "isDefinition": true |}default|]: number };
+////x.[|default|];
+
+const [r0, r1, r2, r3] = test.ranges();
+
+verify.singleReferenceGroup("function f(): void", [r0, r1]);
+verify.singleReferenceGroup("(property) default: number", [r2, r3]);
+
+verify.rangesAreRenameLocations([r0]);
+
+// Can't rename a default import.
+goTo.rangeStart(r1);
+verify.renameInfoFailed();
+
+// Can rename a default property.
+verify.rangesAreRenameLocations([r2, r3]);
diff --git a/tests/cases/fourslash/findAllRefsExportAsNamespace.ts b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts
new file mode 100644
index 00000000000..e6b29fce47f
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts
@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+// `export as namespace` results in global search.
+
+// @Filename: /node_modules/a/index.d.ts
+////export function [|{| "isWriteAccess": true, "isDefinition": true |}f|](): void;
+////export as namespace A;
+
+// @Filename: /b.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}f|] } from "a";
+
+// @Filename: /c.ts
+////A.[|f|]();
+
+verify.noErrors();
+
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+
+const globals = { definition: "function f(): void", ranges: [r0, r2] };
+const imports = { definition: "import f", ranges: [r1] };
+
+verify.referenceGroups([r0, r2], [globals, imports]);
+verify.referenceGroups(r1, [imports, globals]);
diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport.ts b/tests/cases/fourslash/findAllRefsForDefaultExport.ts
index 98e74e281ad..7cd6fe8d57c 100644
--- a/tests/cases/fourslash/findAllRefsForDefaultExport.ts
+++ b/tests/cases/fourslash/findAllRefsForDefaultExport.ts
@@ -10,5 +10,13 @@
 // @Filename: c.ts
 ////import { f } from "./a";
 
-verify.singleReferenceGroup("function f(): void");
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+verify.referenceGroups(r0, [
+    { definition: "function f(): void", ranges: [r0] },
+    { definition: "import g", ranges: [r1, r2] }
+]);
+verify.referenceGroups(r1, [{ definition: "import g", ranges: [r1, r2] }]);
+verify.referenceGroups(r2, [{ definition: "(alias) g(): void\nimport g", ranges: [r1, r2] }]);
+
 verify.goToDefinition("ref", "def");
diff --git a/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts b/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts
new file mode 100644
index 00000000000..c2f4982b653
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsGlobalModuleAugmentation.ts
@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////export {};
+////declare global {
+////    function [|{| "isWriteAccess": true, "isDefinition": true |}f|](): void;
+////}
+
+// @Filename: /b.ts
+////[|f|]();
+
+verify.noErrors();
+verify.singleReferenceGroup("function f(): void");
diff --git a/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts
new file mode 100644
index 00000000000..c57f4a67fda
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts
@@ -0,0 +1,60 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /node_modules/a/index.d.ts
+////declare function [|{| "isWriteAccess": true, "isDefinition": true |}a|](): void;
+////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}a|] {
+////    export const x: number;
+////}
+////export = [|a|];
+
+// Import with different name and we find local refs
+// @Filename: /b.ts
+////import * as [|{| "isWriteAccess": true, "isDefinition": true |}b|] from "a";
+////[|b|]();
+////[|b|].x;
+
+// Import with same name and we find all refs
+// @Filename: /c.ts
+////import * as [|{| "isWriteAccess": true, "isDefinition": true |}a|] from "a";
+////[|a|]();
+////[|a|].x;
+
+verify.noErrors();
+const ranges = test.ranges();
+const [a0, a1, a2, b0, b1, b2, c0, c1, c2] = ranges;
+const aRanges = [a0, a1, a2];
+const bRanges = [b0, b1, b2];
+const cRanges = [c0, c1, c2];
+
+verify.referenceGroups(a0, [
+    { definition: "function a(): void\nnamespace a", ranges: aRanges },
+    { definition: "import b", ranges: bRanges },
+    { definition: "import a", ranges: cRanges }
+]);
+verify.referenceGroups([a1, a2], [
+    { definition: "namespace a\nfunction a(): void", ranges: aRanges },
+    { definition: "import b", ranges: bRanges },
+    { definition: "import a", ranges: cRanges }
+]);
+
+verify.referenceGroups([b0, b0], [
+    { definition: "import b", ranges: bRanges }
+]);
+verify.referenceGroups(b1, [
+    { definition: "(alias) b(): void\nimport b", ranges: bRanges }
+]);
+
+verify.referenceGroups([c0, c2], [
+    { definition: "import a", ranges: cRanges },
+    { definition: "namespace a\nfunction a(): void", ranges: aRanges },
+    { definition: "import b", ranges: bRanges }
+]);
+verify.referenceGroups(c1, [
+    { definition: "(alias) a(): void\nimport a", ranges: cRanges },
+    { definition: "namespace a\nfunction a(): void", ranges: aRanges },
+    { definition: "import b", ranges: bRanges }
+]);
+
+verify.renameLocations(aRanges, aRanges.concat(cRanges));
+verify.rangesAreRenameLocations(bRanges);
+verify.rangesAreRenameLocations(cRanges);
diff --git a/tests/cases/fourslash/findAllRefsModuleAugmentation.ts b/tests/cases/fourslash/findAllRefsModuleAugmentation.ts
new file mode 100644
index 00000000000..c5adab35669
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsModuleAugmentation.ts
@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /node_modules/foo/index.d.ts
+////export type [|{| "isWriteAccess": true, "isDefinition": true |}T|] = number;
+
+// @Filename: /a.ts
+////import * as foo from "foo";
+////declare module "foo" {
+////    export const x: [|T|];
+////}
+
+verify.noErrors();
+verify.singleReferenceGroup("type T = number");
diff --git a/tests/cases/fourslash/findAllRefsOnDefinition2.ts b/tests/cases/fourslash/findAllRefsOnDefinition2.ts
index 6d2438a124c..0212d12a3be 100644
--- a/tests/cases/fourslash/findAllRefsOnDefinition2.ts
+++ b/tests/cases/fourslash/findAllRefsOnDefinition2.ts
@@ -18,4 +18,3 @@ const ranges = test.ranges();
 const [r0, r1] = ranges;
 verify.referenceGroups(r0, [{ definition: "interface Test.start", ranges }]);
 verify.referenceGroups(r1, [{ definition: "interface Second.Test.start", ranges }]);
-
diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases.ts b/tests/cases/fourslash/findAllRefsOnImportAliases.ts
index 7574e11625f..98509ad6938 100644
--- a/tests/cases/fourslash/findAllRefsOnImportAliases.ts
+++ b/tests/cases/fourslash/findAllRefsOnImportAliases.ts
@@ -14,5 +14,13 @@
 
 const ranges = test.ranges();
 const [r0, r1, r2, r3] = ranges;
-verify.referenceGroups([r0, r1, r3], [{ definition: "class Class", ranges }]);
-verify.referenceGroups(r2, [{ definition: "constructor Class(): Class", ranges }]);
+const classes = { definition: "class Class", ranges: [r0] };
+const imports = { definition: "import Class", ranges: [r1, r2] };
+const reExports = { definition: "import Class", ranges: [r3] };
+verify.referenceGroups(r0, [classes, imports, reExports]);
+verify.referenceGroups(r1, [imports, classes, reExports]);
+verify.referenceGroups(r2, [
+    { definition: "(alias) new Class(): Class\nimport Class", ranges: [r1, r2] },
+    classes,
+    reExports
+]);
diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts
index a21d2da4c03..63fb12f5270 100644
--- a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts
+++ b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts
@@ -13,11 +13,20 @@
 ////export { [|{| "isWriteAccess": true, "isDefinition": true |}Class|] as [|{| "isWriteAccess": true, "isDefinition": true |}C3|] } from "./a";
 
 const ranges = test.rangesByText();
-verify.singleReferenceGroup("class Class", ranges.get("Class"));
+const classRanges = ranges.get("Class");
+const [class0, class1, class2] = classRanges;
+const c2Ranges = ranges.get("C2");
+const [c2_0, c2_1] = c2Ranges;
+const c3Ranges = ranges.get("C3");
+const classes = { definition: "class Class", ranges: classRanges };
+const c2s =  { definition: "import C2", ranges: c2Ranges };
+const c3s = { definition: "import C3", ranges: c3Ranges };
 
-const c2s = ranges.get("C2");
-const [c2_0, c2_1] = c2s;
-verify.referenceGroups(c2_0, [{ definition: "import C2", ranges: c2s }]);
-verify.referenceGroups(c2_1, [{ definition: "(alias) new C2(): C2\nimport C2", ranges: c2s }]);
+verify.referenceGroups(classRanges, [classes, c2s, c3s]);
 
-verify.singleReferenceGroup("import C3", ranges.get("C3"));
+verify.referenceGroups(c2_0, [c2s])
+verify.referenceGroups(c2_1, [{ definition: "(alias) new C2(): C2\nimport C2", ranges: c2Ranges }]);
+
+verify.referenceGroups(c3Ranges, [c3s]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/findAllRefsReExportLocal.ts b/tests/cases/fourslash/findAllRefsReExportLocal.ts
new file mode 100644
index 00000000000..25e8accbbc0
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsReExportLocal.ts
@@ -0,0 +1,30 @@
+/// <reference path='fourslash.ts' />
+
+// @noLib: true
+
+// @Filename: /a.ts
+////var [|{| "isWriteAccess": true, "isDefinition": true |}x|];
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] };
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] as [|{| "isWriteAccess": true, "isDefinition": true |}y|] };
+
+// @Filename: /b.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|], [|{| "isWriteAccess": true, "isDefinition": true |}y|] } from "./a";
+////[|x|]; [|y|];
+
+verify.noErrors();
+
+const [ax0, ax1, ax2, ay, bx0, by0, bx1, by1] = test.ranges();
+const axRanges = [ax0, ax1, ax2];
+const bxRanges = [bx0, bx1];
+const byRanges = [by0, by1];
+const axGroup = { definition: "var x: any", ranges: axRanges };
+const bxGroup = { definition: "import x", ranges: bxRanges };
+const ayGroup = { definition: "import y", ranges: [ay] }
+const byGroup = { definition: "import y", ranges: byRanges }
+
+verify.referenceGroups(axRanges, [axGroup, bxGroup, ayGroup, byGroup]);
+verify.referenceGroups(bxRanges, [bxGroup, axGroup, ayGroup, byGroup]);
+verify.referenceGroups(ay, [ayGroup, byGroup]);
+verify.referenceGroups(byRanges, [byGroup, ayGroup]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts
new file mode 100644
index 00000000000..c9d42e53d4e
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts
@@ -0,0 +1,37 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.ts
+////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
+
+// @Filename: /b.ts
+////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
+
+//@Filename: /c.ts
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./b";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./a";
+////[|x|];
+
+// @Filename: /d.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./c";
+
+verify.noErrors();
+const [a, b, cFromB, cFromA, cUse, d] = test.ranges();
+const cFromARanges = [cFromA, cUse];
+
+const aGroup = { definition: "const x: 0", ranges: [a] };
+const cFromAGroup = { definition: "import x", ranges: cFromARanges };
+
+verify.referenceGroups(a, [aGroup, cFromAGroup]);
+
+const bGroup = { definition: "const x: 0", ranges: [b] };
+const cFromBGroup = { definition: "import x", ranges: [cFromB] };
+const dGroup = { definition: "import x", ranges: [d] };
+verify.referenceGroups(b, [bGroup, cFromBGroup, dGroup]);
+
+verify.referenceGroups(cFromB, [cFromBGroup, dGroup, bGroup]);
+verify.referenceGroups(cFromARanges, [cFromAGroup, aGroup]);
+
+verify.referenceGroups(d, [dGroup, cFromBGroup, bGroup]);
+
+verify.rangesAreRenameLocations([a, cFromA, cUse]);
+verify.rangesAreRenameLocations([b, cFromB, d]);
diff --git a/tests/cases/fourslash/findAllRefsReExportStar.ts b/tests/cases/fourslash/findAllRefsReExportStar.ts
new file mode 100644
index 00000000000..86901cfadf2
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsReExportStar.ts
@@ -0,0 +1,18 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.ts
+////export function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](): void {}
+
+// @Filename: /b.ts
+////export * from "./a";
+
+// @Filename: /c.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] } from "./b";
+
+verify.noErrors();
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+const a = { definition: "function foo(): void", ranges: [r0] };
+const c = { definition: "import foo", ranges: [r1] };
+verify.referenceGroups(r0, [a, c]);
+verify.referenceGroups(r1, [c, a]);
diff --git a/tests/cases/fourslash/findAllRefsReExports.ts b/tests/cases/fourslash/findAllRefsReExports.ts
new file mode 100644
index 00000000000..593db568c8a
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsReExports.ts
@@ -0,0 +1,61 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.ts
+////export function [|{| "isWriteAccess": true, "isDefinition": true |}foo|](): void {}
+
+// @Filename: /b.ts
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] as [|{| "isWriteAccess": true, "isDefinition": true |}bar|] } from "./a";
+
+// @Filename: /c.ts
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}foo|] as [|{| "isWriteAccess": true, "isDefinition": true |}default|] } from "./a";
+
+// @Filename: /d.ts
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}default|] } from "./c";
+
+// @Filename: /e.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}bar|] } from "./b";
+////import [|{| "isWriteAccess": true, "isDefinition": true |}baz|] from "./c";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}default|] as [|{| "isWriteAccess": true, "isDefinition": true |}bang|] } from "./c";
+////import [|{| "isWriteAccess": true, "isDefinition": true |}boom|] from "./d";
+////[|bar|](); [|baz|](); [|bang|](); [|boom|]();
+
+verify.noErrors();
+const [foo0, foo1, bar0, foo2, defaultC, defaultD, bar1, baz0, defaultE, bang0, boom0, bar2, baz1, bang1, boom1] = test.ranges();
+const a = { definition: "function foo(): void", ranges: [foo0, foo1, foo2] };
+const b = { definition: "import bar", ranges: [bar0] };
+const c = { definition: "import default", ranges: [defaultC, defaultE] };
+const d = { definition: "import default", ranges: [defaultD] };
+const eBar = { definition: "import bar", ranges: [bar1, bar2] };
+const eBaz = { definition: "import baz", ranges: [baz0, baz1] };
+const eBang = { definition: "import bang", ranges: [bang0, bang1] };
+const eBoom = { definition: "import boom", ranges: [boom0, boom1] };
+
+verify.referenceGroups([foo0, foo1, foo2], [a, b, eBar, c, d, eBoom, eBaz, eBang]);
+
+verify.referenceGroups(bar0, [b, eBar]);
+verify.referenceGroups(bar1, [eBar, b]);
+verify.referenceGroups(bar2, [{ ...eBar, definition: "(alias) bar(): void\nimport bar" }, b]);
+
+verify.referenceGroups([defaultC], [c, d, eBoom, eBaz, eBang]);
+verify.referenceGroups(defaultD, [d, eBoom, a, b, eBar,c, eBaz, eBang]);
+verify.referenceGroups(defaultE, [c, d, eBoom, eBaz, eBang]);
+verify.referenceGroups(baz0, [eBaz]);
+verify.referenceGroups(baz1, [{ ...eBaz, definition: "(alias) baz(): void\nimport baz" }]);
+
+verify.referenceGroups(bang0, [eBang]);
+verify.referenceGroups(bang1, [{ ...eBang, definition: "(alias) bang(): void\nimport bang" }]);
+
+verify.referenceGroups(boom0, [eBoom]);
+verify.referenceGroups(boom1, [{ ...eBoom, definition: "(alias) boom(): void\nimport boom" }]);
+
+test.rangesByText().forEach((ranges, text) => {
+    if (text === "default") {
+        for (const range of ranges) {
+            goTo.rangeStart(defaultC);
+            verify.renameInfoFailed();
+        }
+    }
+    else {
+        verify.rangesAreRenameLocations(ranges);
+    }
+});
diff --git a/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts
new file mode 100644
index 00000000000..c1a49b3b5b0
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts
@@ -0,0 +1,20 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.ts
+////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
+
+//@Filename: /b.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] as [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./a";
+////[|x|];
+
+verify.noErrors();
+const [r0, r1, r2, r3] = test.ranges();
+const aRanges = [r0, r1];
+const bRanges = [r2, r3];
+const aGroup = { definition: "const x: 0", ranges: aRanges };
+const bGroup =  { definition: "import x", ranges: bRanges };
+verify.referenceGroups(aRanges, [aGroup, bGroup]);
+verify.referenceGroups(bRanges, [bGroup]);
+
+verify.rangesAreRenameLocations(aRanges);
+verify.rangesAreRenameLocations(aRanges);
diff --git a/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts b/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts
index 544a3238e3b..0c6f088d06b 100644
--- a/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts
+++ b/tests/cases/fourslash/findAllRefsWithShorthandPropertyAssignment.ts
@@ -7,7 +7,7 @@
 //// obj.[|name|];
 
 const [r0, r1, r2, r3, r4] = test.ranges();
-verify.referenceGroups([r0, r3], [{ definition: "var name: string", ranges: [r0, r1, r3] }]);
+verify.referenceGroups(r0, [{ definition: "var name: string", ranges: [r0, r1, r3] }]); //r3
 verify.referenceGroups(r1, [
     { definition: "var name: string", ranges: [r0, r3] },
     { definition: "(property) name: string", ranges: [r1, r4] }
diff --git a/tests/cases/fourslash/findReferencesJSXTagName.ts b/tests/cases/fourslash/findReferencesJSXTagName.ts
index 5f8bc3a475f..740eb395b3c 100644
--- a/tests/cases/fourslash/findReferencesJSXTagName.ts
+++ b/tests/cases/fourslash/findReferencesJSXTagName.ts
@@ -13,4 +13,7 @@
 
 const ranges = test.ranges();
 const [r0, r1, r2] = ranges;
-verify.referenceGroups(ranges, [{ definition: "const SubmissionComp: (submission: any) => any", ranges: [r2, r0, r1] }]);
+const imports = { definition: "import SubmissionComp", ranges: [r0, r1] };
+const def = { definition: "const SubmissionComp: (submission: any) => any", ranges: [r2] };
+verify.referenceGroups([r0, r1], [imports, def]);
+verify.referenceGroups(r2, [def, imports]);
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index 0e302a649e6..374dfd33c7d 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -184,6 +184,7 @@ declare namespace FourSlashInterface {
         verifyGetEmitOutputForCurrentFile(expected: string): void;
         verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void;
         noReferences(markerNameOrRange?: string | Range): void;
+        symbolAtLocation(startRange: Range, ...declarationRanges: Range[]): void;
         /**
          * @deprecated, prefer 'referenceGroups'
          * Like `referencesAre`, but goes to `start` first.
@@ -197,7 +198,8 @@ declare namespace FourSlashInterface {
         referenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void;
         singleReferenceGroup(definition: string, ranges?: Range[]): void;
         rangesAreOccurrences(isWriteAccess?: boolean): void;
-        rangesAreRenameLocations(findInStrings?: boolean, findInComments?: boolean): void;
+        rangesWithSameTextAreRenameLocations(): void;
+        rangesAreRenameLocations(options?: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges?: Range[] });
         /**
          * Performs `referencesOf` for every range on the whole set.
          * If `ranges` is omitted, this is `test.ranges()`.
@@ -215,6 +217,8 @@ declare namespace FourSlashInterface {
         currentSignatureParameterCountIs(expected: number): void;
         currentSignatureTypeParameterCountIs(expected: number): void;
         currentSignatureHelpIs(expected: string): void;
+        // Checks that there are no compile errors.
+        noErrors(): void;
         numberOfErrorsInCurrentFile(expected: number): void;
         baselineCurrentFileBreakpointLocations(): void;
         baselineCurrentFileNameOrDottedNameSpans(): void;
@@ -256,7 +260,7 @@ declare namespace FourSlashInterface {
         }[]): void;
         renameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string): void;
         renameInfoFailed(message?: string): void;
-        renameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]): void;
+        renameLocations(startRanges: Range | Range[], options: Range[] | { findInStrings?: boolean, findInComments?: boolean, ranges: Range[] }): void;
 
         /** Verify the quick info available at the current marker. */
         quickInfoIs(expectedText: string, expectedDocumentation?: string): void;
diff --git a/tests/cases/fourslash/functionTypes.ts b/tests/cases/fourslash/functionTypes.ts
index 813dfa8cdcb..fdcb924af98 100644
--- a/tests/cases/fourslash/functionTypes.ts
+++ b/tests/cases/fourslash/functionTypes.ts
@@ -20,7 +20,7 @@
 ////typeof C.k./*6*/caller === 'function';
 ////l./*7*/prototype = Object.prototype;
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 for (var i = 1; i <= 7; i++) {
     goTo.marker('' + i);
     verify.completionListCount(8);
diff --git a/tests/cases/fourslash/funduleWithRecursiveReference.ts b/tests/cases/fourslash/funduleWithRecursiveReference.ts
index aa0b549965a..6291131acb0 100644
--- a/tests/cases/fourslash/funduleWithRecursiveReference.ts
+++ b/tests/cases/fourslash/funduleWithRecursiveReference.ts
@@ -8,4 +8,4 @@
 ////}
 
 verify.quickInfoAt("", "var M.C.C: typeof M.C");
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericInterfacePropertyInference1.ts b/tests/cases/fourslash/genericInterfacePropertyInference1.ts
index 00344988a72..60f4cf0dda3 100644
--- a/tests/cases/fourslash/genericInterfacePropertyInference1.ts
+++ b/tests/cases/fourslash/genericInterfacePropertyInference1.ts
@@ -20,7 +20,7 @@
 ////    ofT: T;
 ////    ofFooNum: Foo<number>;
 ////    ofInterface: I;
-////    ofIG4: { x: number }; 
+////    ofIG4: { x: number };
 ////    ofIG6: { x: T };
 ////    ofC2: C<number>;
 ////    ofC4: C<{ x: T }>
@@ -35,33 +35,33 @@
 ////// T is any
 ////var f_/*a1*/r1  = f.prim1;
 ////var f_/*a2*/r2  = f.prim2;
-////var f_/*a3*/r3  = f.ofT; 
+////var f_/*a3*/r3  = f.ofT;
 ////var f_/*a4*/r5  = f.ofFooNum;
 ////var f_/*a5*/r8  = f.ofInterface;
 ////var f_/*a6*/r12 = f.ofIG4;
-////var f_/*a7*/r14 = f.ofIG6; 
+////var f_/*a7*/r14 = f.ofIG6;
 ////var f_/*a8*/r18 = f.ofC2;
-////var f_/*a9*/r20 = f.ofC4; 
+////var f_/*a9*/r20 = f.ofC4;
 ////
 ////// T is number
 ////var f2_/*b1*/r1  = f2.prim1;
 ////var f2_/*b2*/r2  = f2.prim2;
-////var f2_/*b3*/r3  = f2.ofT; 
-////var f2_/*b4*/r5  = f2.ofFooNum; 
+////var f2_/*b3*/r3  = f2.ofT;
+////var f2_/*b4*/r5  = f2.ofFooNum;
 ////var f2_/*b5*/r8  = f2.ofInterface;
 ////var f2_/*b6*/r12 = f2.ofIG4;
-////var f2_/*b7*/r14 = f2.ofIG6; 
+////var f2_/*b7*/r14 = f2.ofIG6;
 ////var f2_/*b8*/r18 = f2.ofC2;
-////var f2_/*b9*/r20 = f2.ofC4; 
+////var f2_/*b9*/r20 = f2.ofC4;
 ////
 ////// T is I
 ////var f3_/*c1*/r1  = f3.prim1;
 ////var f3_/*c2*/r2  = f3.prim2;
-////var f3_/*c3*/r3  = f3.ofT; 
+////var f3_/*c3*/r3  = f3.ofT;
 ////var f3_/*c4*/r5  = f3.ofFooNum;
 ////var f3_/*c5*/r8  = f3.ofInterface;
 ////var f3_/*c6*/r12 = f3.ofIG4;
-////var f3_/*c7*/r14 = f3.ofIG6; 
+////var f3_/*c7*/r14 = f3.ofIG6;
 ////var f3_/*c8*/r18 = f3.ofC2;
 ////var f3_/*c9*/r20 = f3.ofC4;
 ////
@@ -74,20 +74,20 @@
 ////var f4_/*d6*/r12 = f4.ofIG4;
 ////var f4_/*d7*/r14 = f4.ofIG6;
 ////var f4_/*d8*/r18 = f4.ofC2;
-////var f4_/*d9*/r20 = f4.ofC4; 
+////var f4_/*d9*/r20 = f4.ofC4;
 ////
 ////// T is Foo<number>
 ////var f5_/*e1*/r1  = f5.prim1;
 ////var f5_/*e2*/r2  = f5.prim2;
-////var f5_/*e3*/r3  = f5.ofT; 
+////var f5_/*e3*/r3  = f5.ofT;
 ////var f5_/*e4*/r5  = f5.ofFooNum;
 ////var f5_/*e5*/r8  = f5.ofInterface;
 ////var f5_/*e6*/r12 = f5.ofIG4;
-////var f5_/*e7*/r14 = f5.ofIG6; 
+////var f5_/*e7*/r14 = f5.ofIG6;
 ////var f5_/*e8*/r18 = f5.ofC2;
 ////var f5_/*e9*/r20 = f5.ofC4;
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 verify.quickInfos({
     "a1": "var f_r1: number",
diff --git a/tests/cases/fourslash/genericInterfacePropertyInference2.ts b/tests/cases/fourslash/genericInterfacePropertyInference2.ts
index 1da115e595b..a3600865a9e 100644
--- a/tests/cases/fourslash/genericInterfacePropertyInference2.ts
+++ b/tests/cases/fourslash/genericInterfacePropertyInference2.ts
@@ -32,7 +32,7 @@
 ////var f_/*a1*/r4 = f.ofFooT;
 ////var f_/*a2*/r7 = f.ofFooFooNum;
 ////var f_/*a3*/r9 = f.ofIG;
-////var f_/*a5*/r13 = f.ofIG5; 
+////var f_/*a5*/r13 = f.ofIG5;
 ////var f_/*a7*/r17 = f.ofC1;
 ////
 ////// T is number
@@ -60,10 +60,10 @@
 ////var f5_/*e1*/r4 = f5.ofFooT;
 ////var f5_/*e2*/r7 = f5.ofFooFooNum;
 ////var f5_/*e3*/r9 = f5.ofIG;
-////var f5_/*e5*/r13 = f5.ofIG5; 
+////var f5_/*e5*/r13 = f5.ofIG5;
 ////var f5_/*e7*/r17 = f5.ofC1;
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 verify.quickInfos({
     a1: "var f_r4: Foo<any>",
diff --git a/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts b/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts
index f2b685937ea..36ca3bb57f8 100644
--- a/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts
+++ b/tests/cases/fourslash/genericInterfaceWithInheritanceEdit1.ts
@@ -8,12 +8,12 @@
 ////    value(): T;
 ////}
 ////interface ChainedArray<T> extends ChainedObject<Array<T>> {
-////    
+////
 ////    extend(...sources: any[]): ChainedArray<T>;
 ////}
 //// /*1*/
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insert(' ');
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericMapTyping1.ts b/tests/cases/fourslash/genericMapTyping1.ts
index 8cc9fe2d8c7..47514c96168 100644
--- a/tests/cases/fourslash/genericMapTyping1.ts
+++ b/tests/cases/fourslash/genericMapTyping1.ts
@@ -20,7 +20,7 @@
 ////var c/*5*/cc = _(aaa).map(xx => xx.length);  // Should not error, should be any[]
 ////var d/*6*/dd = aaa.map(xx => xx.length);     // should not error, should be any[]
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 verify.quickInfos({
     1: "var bb: number[]",
     2: "var cc: number[]",
diff --git a/tests/cases/fourslash/genericMethodParam.ts b/tests/cases/fourslash/genericMethodParam.ts
index 7e8bf916b6c..a7ee60b3ded 100644
--- a/tests/cases/fourslash/genericMethodParam.ts
+++ b/tests/cases/fourslash/genericMethodParam.ts
@@ -5,14 +5,14 @@
 //// }
 //// /*2*/
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insertLine("constructor(){}");
 edit.insertLine("foo(a: T) {");
 edit.insertLine("    return a;");
 edit.insertLine("}");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('2');
 edit.insertLine("var x = new C<number>();");
 edit.insertLine("var y: number = x.foo(5);");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/genericObjectBaseType.ts b/tests/cases/fourslash/genericObjectBaseType.ts
index de0f508d0f0..acca6c3c33b 100644
--- a/tests/cases/fourslash/genericObjectBaseType.ts
+++ b/tests/cases/fourslash/genericObjectBaseType.ts
@@ -11,4 +11,4 @@
 //// /*1*/
 
 goTo.marker('1');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/genericRespecialization1.ts b/tests/cases/fourslash/genericRespecialization1.ts
index e8db5eafc4a..3264052aea9 100644
--- a/tests/cases/fourslash/genericRespecialization1.ts
+++ b/tests/cases/fourslash/genericRespecialization1.ts
@@ -63,13 +63,13 @@
 //// }
 ////  /*1*/
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insertLine('');
 edit.insertLine('');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('2');
 edit.deleteAtCaret("Cookie".length);
 edit.insert("any");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 edit.insertLine('var narnia = new GenericPlanet2<Cookie, string>('); // shouldn't crash at this point
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericTypeArgumentInference1.ts b/tests/cases/fourslash/genericTypeArgumentInference1.ts
index 63c93628b47..5d4d38c4865 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference1.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference1.ts
@@ -30,4 +30,4 @@ verify.quickInfos({
     4: "var r4: any",
     41: "(method) Underscore.Static.all<any>(list: any[], iterator?: Underscore.Iterator<any, boolean>, context?: any): any"
 });
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericTypeArgumentInference2.ts b/tests/cases/fourslash/genericTypeArgumentInference2.ts
index 6b55b11f03a..a93e5ac6ea5 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference2.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference2.ts
@@ -30,4 +30,4 @@ verify.quickInfos({
     4: "var r4: any",
     41: "(method) Underscore.Static.all<any>(list: any[], iterator?: Underscore.Iterator<any, boolean>, context?: any): any"
 });
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts
index 9cdfb0aa0f7..4268e5d180d 100644
--- a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts
+++ b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts
@@ -5,4 +5,9 @@
 ////import { [|{| "isWriteAccess": true, "isDefinition": true |}x|] } from "./m";
 ////const y = [|x|];
 
-verify.singleReferenceGroup("var x: number");
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+const defs = { definition: "var x: number", ranges: [r0] };
+const imports = { definition: "import x", ranges: [r1, r2] };
+verify.referenceGroups(r0, [defs, imports]);
+verify.referenceGroups([r1, r2], [imports, defs]);
diff --git a/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts b/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts
index 13a2dccfd26..9e990dddbfc 100644
--- a/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts
+++ b/tests/cases/fourslash/getSemanticDiagnosticForDeclaration1.ts
@@ -4,6 +4,4 @@
 // @Filename: File.d.ts
 //// declare var v: string;
 
-verify.numberOfErrorsInCurrentFile(0);
-
-
+verify.noErrors();
diff --git a/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts b/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts
index cdcde01054e..917d394601f 100644
--- a/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts
+++ b/tests/cases/fourslash/getSemanticDiagnosticForNoDeclaration.ts
@@ -5,6 +5,6 @@
 //// interface privateInterface {}
 //// export class Bar implements /*1*/privateInterface/*2*/{ }
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 
diff --git a/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts b/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts
index 38afd0cfb3d..7ec63c4e94b 100644
--- a/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts
+++ b/tests/cases/fourslash/goToImplementationInterfaceMethod_00.ts
@@ -22,4 +22,4 @@
 //// }
 
 verify.allRangesAppearInImplementationList("function_call");
-verify.allRangesAppearInImplementationList("declaration");
\ No newline at end of file
+verify.allRangesAppearInImplementationList("declaration");
diff --git a/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts b/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts
index f8dcc0a1f39..b3724c6e40d 100644
--- a/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts
+++ b/tests/cases/fourslash/incrementalUpdateToClassImplementingGenericClass.ts
@@ -16,7 +16,7 @@
 
 
 goTo.marker('1');
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 edit.insert("//");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/javaScriptClass2.ts b/tests/cases/fourslash/javaScriptClass2.ts
index d6daa320c5a..dcdac24c7b8 100644
--- a/tests/cases/fourslash/javaScriptClass2.ts
+++ b/tests/cases/fourslash/javaScriptClass2.ts
@@ -7,16 +7,11 @@
 //// class Foo {
 ////    constructor() {
 ////        this.[|union|] = 'foo';
-////        this./*1*/[|union|] = 100;
+////        this.[|union|] = 100;
 ////    }
-////    method() { return this./*2*/[|union|]; }
+////    method() { return this.[|union|]; }
 //// }
 //// var x = new Foo();
-//// x./*3*/[|union|];
+//// x.[|union|];
 
-goTo.marker('1');
-verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
-goTo.marker('2');
-verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
-goTo.marker('3');
-verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/javascriptModules22.ts b/tests/cases/fourslash/javascriptModules22.ts
index 89fa99b5ea2..caa8c6798b1 100644
--- a/tests/cases/fourslash/javascriptModules22.ts
+++ b/tests/cases/fourslash/javascriptModules22.ts
@@ -29,4 +29,4 @@ verify.completionListContains("name");
 edit.insert("name;\nsausages.");
 verify.completionListContains("eggs");
 edit.insert("eggs;");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/jsDocFunctionSignatures4.ts b/tests/cases/fourslash/jsDocFunctionSignatures4.ts
index e2b443d8d40..634eb312ff5 100644
--- a/tests/cases/fourslash/jsDocFunctionSignatures4.ts
+++ b/tests/cases/fourslash/jsDocFunctionSignatures4.ts
@@ -7,5 +7,4 @@
 ////   * @param {function (string):void} y */
 //// function fn(x, y) { }
 
-verify.numberOfErrorsInCurrentFile(0);
-
+verify.noErrors();
diff --git a/tests/cases/fourslash/jsxSpreadReference.ts b/tests/cases/fourslash/jsxSpreadReference.ts
index 595549967e6..915dbdcecdf 100644
--- a/tests/cases/fourslash/jsxSpreadReference.ts
+++ b/tests/cases/fourslash/jsxSpreadReference.ts
@@ -18,6 +18,4 @@
 //// var x = <MyClass {...[|n/*src*/n|]}></MyClass>;
 
 verify.goToDefinition("src", "dst");
-
-goTo.marker('src');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/memberConstructorEdits.ts b/tests/cases/fourslash/memberConstructorEdits.ts
index 45d631cd2b8..c1cf9507d6e 100644
--- a/tests/cases/fourslash/memberConstructorEdits.ts
+++ b/tests/cases/fourslash/memberConstructorEdits.ts
@@ -10,17 +10,17 @@
 ////             return this.m(0);
 ////         }
 ////     }
-////     export class B extends A { 
+////     export class B extends A {
 ////     	constructor(a: string) {
 ////			super(a);
 ////		}
-////		/*1*/ 
+////		/*1*/
 ////	 }
 ////	 var a = new A("s");
 ////	 var b = new B("s");
 //// }
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insert("public m(n: number) { return 0; }");
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
diff --git a/tests/cases/fourslash/memberOverloadEdits.ts b/tests/cases/fourslash/memberOverloadEdits.ts
index 43553a81179..68972235c5f 100644
--- a/tests/cases/fourslash/memberOverloadEdits.ts
+++ b/tests/cases/fourslash/memberOverloadEdits.ts
@@ -12,7 +12,7 @@
 ////     export class B extends A { /*1*/ }
 //// }
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 goTo.marker('1');
 edit.insert("public m(n: number) { return 0; }");
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/moduleReferenceValue.ts b/tests/cases/fourslash/moduleReferenceValue.ts
index cce06ad1e1b..a5a4bc7366e 100644
--- a/tests/cases/fourslash/moduleReferenceValue.ts
+++ b/tests/cases/fourslash/moduleReferenceValue.ts
@@ -17,7 +17,7 @@
 ////    r4 = x; // 3
 ////}
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 verify.eval("r1", undefined);
 verify.eval("r2", 2);
 verify.eval("r3", 2);
diff --git a/tests/cases/fourslash/multiModuleClodule1.ts b/tests/cases/fourslash/multiModuleClodule1.ts
index 0cec8373fb7..5aeb2e709f5 100644
--- a/tests/cases/fourslash/multiModuleClodule1.ts
+++ b/tests/cases/fourslash/multiModuleClodule1.ts
@@ -39,4 +39,4 @@ verify.completionListContains('x');
 verify.completionListContains('foo');
 verify.completionListContains('boo');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/multiModuleFundule1.ts b/tests/cases/fourslash/multiModuleFundule1.ts
index 47cb44dedbf..71fd64771d6 100644
--- a/tests/cases/fourslash/multiModuleFundule1.ts
+++ b/tests/cases/fourslash/multiModuleFundule1.ts
@@ -30,4 +30,4 @@ verify.completionListContains('x');
 verify.completionListContains('foo');
 edit.insert('x;');
 
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/parenthesisFatArrows.ts b/tests/cases/fourslash/parenthesisFatArrows.ts
index 1751e50afc8..ea123b986e4 100644
--- a/tests/cases/fourslash/parenthesisFatArrows.ts
+++ b/tests/cases/fourslash/parenthesisFatArrows.ts
@@ -6,6 +6,6 @@
 ////(y) => y;
 ////x => x;
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 verify.not.errorExistsBeforeMarker();
 verify.not.errorExistsAfterMarker();
\ No newline at end of file
diff --git a/tests/cases/fourslash/quickInfoMeaning.ts b/tests/cases/fourslash/quickInfoMeaning.ts
index 414fcc0c86d..a3b9f988e1d 100644
--- a/tests/cases/fourslash/quickInfoMeaning.ts
+++ b/tests/cases/fourslash/quickInfoMeaning.ts
@@ -18,7 +18,7 @@
 ////const x = foo/*foo_value*/;
 ////const i: foo/*foo_type*/ = { x: 1, y: 2 };
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
 
 verify.navigationItemsListCount(2, "foo", "exact");
 verify.navigationItemsListContains("foo", "alias", "foo", "exact");
@@ -49,7 +49,6 @@ verify.goToDefinitionIs("foo_type_declaration");
 ////const x = bar/*bar_value*/;
 ////const i: bar/*bar_type*/ = { x: 1, y: 2 };
 
-verify.numberOfErrorsInCurrentFile(0);
 verify.navigationItemsListCount(2, "bar", "exact");
 verify.navigationItemsListContains("bar", "alias", "bar", "exact");
 verify.navigationItemsListContains("bar", "interface", "bar", "exact");
diff --git a/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts b/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts
index 78e39338193..d74883b982d 100644
--- a/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts
+++ b/tests/cases/fourslash/quickInfoOnMergedInterfacesWithIncrementalEdits.ts
@@ -23,4 +23,4 @@ edit.insert('a');
 verify.quickInfoIs("(property) B<string>.bar: string");
 goTo.marker('2');
 verify.quickInfoIs("var r4: string");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/quickInfoOnMergedModule.ts b/tests/cases/fourslash/quickInfoOnMergedModule.ts
index 03dd13e823e..6d170d2ec3c 100644
--- a/tests/cases/fourslash/quickInfoOnMergedModule.ts
+++ b/tests/cases/fourslash/quickInfoOnMergedModule.ts
@@ -16,4 +16,4 @@
 ////}
 
 verify.quickInfoAt("1", "(property) M2.A.foo: string", undefined);
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
diff --git a/tests/cases/fourslash/referencesForAmbients2.ts b/tests/cases/fourslash/referencesForAmbients2.ts
new file mode 100644
index 00000000000..8654d90f854
--- /dev/null
+++ b/tests/cases/fourslash/referencesForAmbients2.ts
@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: /defA.ts
+////declare module "a" {
+////    export type [|{| "isWriteAccess": true, "isDefinition": true |}T|] = number;
+////}
+
+// @Filename: /defB.ts
+////declare module "b" {
+////    export import a = require("a");
+////    export const x: a.[|T|];
+////}
+
+// @Filename: /defC.ts
+////declare module "c" {
+////    import b = require("b");
+////    const x: b.a.[|T|];
+////}
+
+verify.noErrors();
+verify.singleReferenceGroup("type T = number");
diff --git a/tests/cases/fourslash/renameAcrossMultipleProjects.ts b/tests/cases/fourslash/renameAcrossMultipleProjects.ts
index 44b5c0baef4..2cc5824a843 100644
--- a/tests/cases/fourslash/renameAcrossMultipleProjects.ts
+++ b/tests/cases/fourslash/renameAcrossMultipleProjects.ts
@@ -1,7 +1,7 @@
 /// <reference path="fourslash.ts" />
 
 //@Filename: a.ts
-////var /*1*/[|x|]: number;
+////var [|x|]: number;
 
 //@Filename: b.ts
 /////// <reference path="a.ts" />
@@ -11,7 +11,4 @@
 /////// <reference path="a.ts" />
 ////[|x|]++;
 
-goTo.file("a.ts");
-goTo.marker("1");
-
-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 35916295a8e..8416d12f4b2 100644
--- a/tests/cases/fourslash/renameAliasExternalModule2.ts
+++ b/tests/cases/fourslash/renameAliasExternalModule2.ts
@@ -5,7 +5,9 @@
 ////export = [|SomeModule|];
 
 // @Filename: b.ts
-////import M = require("./a");
-////import C = M.SomeClass;
+////import [|M|] = require("./a");
+////import C = [|M|].SomeClass;
 
-verify.rangesAreRenameLocations();
+const [r0, r1, r2, r3] = test.ranges();
+verify.rangesAreRenameLocations([r0, r1]);
+verify.rangesAreRenameLocations([r2, r3]);
diff --git a/tests/cases/fourslash/renameCommentsAndStrings1.ts b/tests/cases/fourslash/renameCommentsAndStrings1.ts
index b7a1f5d61ae..cd350e3046c 100644
--- a/tests/cases/fourslash/renameCommentsAndStrings1.ts
+++ b/tests/cases/fourslash/renameCommentsAndStrings1.ts
@@ -1,11 +1,10 @@
 /// <reference path="fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to Bar in a comment.
 ////    "this is a reference to Bar in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameCommentsAndStrings2.ts b/tests/cases/fourslash/renameCommentsAndStrings2.ts
index 590f3a0833f..e31c3b76900 100644
--- a/tests/cases/fourslash/renameCommentsAndStrings2.ts
+++ b/tests/cases/fourslash/renameCommentsAndStrings2.ts
@@ -1,11 +1,11 @@
 /// <reference path="fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to Bar in a comment.
 ////    "this is a reference to [|Bar|] in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ false);
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges[0], { findInStrings: true, ranges })
diff --git a/tests/cases/fourslash/renameCommentsAndStrings3.ts b/tests/cases/fourslash/renameCommentsAndStrings3.ts
index 5f1aa09a948..7d88ddf2438 100644
--- a/tests/cases/fourslash/renameCommentsAndStrings3.ts
+++ b/tests/cases/fourslash/renameCommentsAndStrings3.ts
@@ -1,11 +1,11 @@
 /// <reference path="fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to [|Bar|] in a comment.
 ////    "this is a reference to Bar in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ true);
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges[0], { findInComments: true, ranges });
diff --git a/tests/cases/fourslash/renameCommentsAndStrings4.ts b/tests/cases/fourslash/renameCommentsAndStrings4.ts
index 4f8b7b98cd4..b3975209fc4 100644
--- a/tests/cases/fourslash/renameCommentsAndStrings4.ts
+++ b/tests/cases/fourslash/renameCommentsAndStrings4.ts
@@ -1,11 +1,11 @@
 /// <reference path="fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
 ////function /**/[|Bar|]() {
 ////    // This is a reference to [|Bar|] in a comment.
 ////    "this is a reference to [|Bar|] in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true);
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges[0], { findInStrings: true, findInComments: true, ranges });
diff --git a/tests/cases/fourslash/renameCrossJsTs01.ts b/tests/cases/fourslash/renameCrossJsTs01.ts
index 52cb4c587d1..025118ef7f7 100644
--- a/tests/cases/fourslash/renameCrossJsTs01.ts
+++ b/tests/cases/fourslash/renameCrossJsTs01.ts
@@ -6,7 +6,6 @@
 
 // @Filename: b.ts
 ////import { [|area|] } from './a';
-////var t = /**/[|area|](10);
+////var t = [|area|](10);
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations()
diff --git a/tests/cases/fourslash/renameCrossJsTs02.ts b/tests/cases/fourslash/renameCrossJsTs02.ts
deleted file mode 100644
index 7ff1ae96ff3..00000000000
--- a/tests/cases/fourslash/renameCrossJsTs02.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-// @allowJs: true
-// @Filename: a.js
-////exports./**/[|area|] = function (r) { return r * r; }
-
-// @Filename: b.ts
-////import { [|area|] } from './a';
-////var t = [|area|](10);
-
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameDefaultImport.ts b/tests/cases/fourslash/renameDefaultImport.ts
index bcac46d7a63..086a05f6b99 100644
--- a/tests/cases/fourslash/renameDefaultImport.ts
+++ b/tests/cases/fourslash/renameDefaultImport.ts
@@ -16,14 +16,15 @@ verify.occurrencesAtPositionCount(1);
 
 const ranges = test.ranges();
 const [C, B0, B1] = ranges;
-verify.referenceGroups([C, B0], [{ definition: "class B", ranges }]);
-verify.referenceGroups(B1, [{ definition: "constructor B(): B", ranges }]);
 
-goTo.rangeStart(C);
-verify.renameLocations(false, false, [C, B0, B1]);
+const classes = { definition: "class B", ranges: [C] };
+const imports = { definition: "import B", ranges: [B0, B1] };
+verify.referenceGroups(C, [classes, imports]);
+verify.referenceGroups(B0, [imports, classes]);
+verify.referenceGroups(B1, [
+    { definition: "(alias) new B(): B\nimport B", ranges: [B0, B1] },
+    classes
+]);
 
-const rangesInB = [B0, B1];
-for (const r of rangesInB) {
-    goTo.rangeStart(r);
-    verify.renameLocations(false, false, rangesInB);
-}
+verify.renameLocations(C, ranges);
+verify.rangesAreRenameLocations([B0, B1]);
diff --git a/tests/cases/fourslash/renameDefaultImportDifferentName.ts b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
index 590c81c650c..ac44c26c443 100644
--- a/tests/cases/fourslash/renameDefaultImportDifferentName.ts
+++ b/tests/cases/fourslash/renameDefaultImportDifferentName.ts
@@ -16,14 +16,12 @@ verify.occurrencesAtPositionCount(1);
 
 const ranges = test.ranges();
 const [C, B0, B1] = ranges;
-verify.referenceGroups([C, B0], [{ definition: "class C", ranges }]);
-verify.referenceGroups(B1, [{ definition: "constructor C(): B", ranges }]);
+const bRanges = [B0, B1];
+const classes = { definition: "class C", ranges: [C] };
+const imports = { definition: "import B", ranges: [B0, B1] };
+verify.referenceGroups(C, [classes, imports]);
+verify.referenceGroups(B0, [imports]);
+verify.referenceGroups(B1, [{ definition: "(alias) new B(): B\nimport B", ranges: bRanges }]);
 
-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);
-}
+verify.rangesAreRenameLocations([C]);
+verify.rangesAreRenameLocations(bRanges);
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts b/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts
index 6be57b81fa2..0ef6f672e00 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentInFor.ts
@@ -1,20 +1,18 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    /*1*/[|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 ({ /*2*/[|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++) {
 ////}
 
-goTo.marker("1");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-
-goTo.marker("2");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+const ranges = test.ranges();
+const [r0, , r2] = ranges;
+verify.renameLocations([r0, r2], ranges);
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts b/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts
index d965875d259..b452ca7c9a7 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentInForOf.ts
@@ -1,7 +1,7 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface I {
-////    /*1*/[|property1|]: number;
+////    [|property1|]: number;
 ////    property2: string;
 ////}
 ////var elems: I[];
@@ -9,12 +9,10 @@
 ////var property1: number, p2: number;
 ////for ({ [|property1|] } of elems) {
 ////    property1++;
-////}
-////for ({ /*2*/[|property1|]: p2 } of elems) {
-////}
-
-goTo.marker("1");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-
-goTo.marker("2");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+////}
+////for ({ [|property1|]: p2 } of elems) {
+////}
+
+const ranges = test.ranges();
+const [r0, , r2] = ranges;
+verify.renameLocations([r0, r2], ranges);
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts
index 9d5d2a041e5..57191e6d6ab 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInArrayLiteral.ts
@@ -1,15 +1,13 @@
 /// <reference path='fourslash.ts' />
 
-////interface I {
-////    /*1*/[|property1|]: number;
-////    property2: string;
-////}
-////var elems: I[], p1: number, property1: number;
-////[{ /*2*/[|property1|]: p1 }] = elems;
-////[{ [|property1|] }] = elems;
+////interface I {
+////    [|property1|]: number;
+////    property2: string;
+////}
+////var elems: I[], p1: number, property1: number;
+////[{ [|property1|]: p1 }] = elems;
+////[{ [|property1|] }] = elems;
 
-goTo.marker("1");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-
-goTo.marker("2");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.renameLocations([r0, r1], ranges);
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts
index e603c82dbd7..fe8961aa18c 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInFor.ts
@@ -1,22 +1,20 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface MultiRobot {
 ////    name: string;
 ////    skills: {
-////        /*1*/[|primary|]: string;
+////        [|primary|]: string;
 ////        secondary: string;
 ////    };
 ////}
 ////let multiRobot: MultiRobot;
-////for ({ skills: { /*2*/[|primary|]: primaryA, secondary: secondaryA } } = multiRobot, i = 0; i < 1; i++) {
+////for ({ skills: { [|primary|]: primaryA, secondary: secondaryA } } = multiRobot, i = 0; i < 1; i++) {
 ////    console.log(primaryA);
 ////}
 ////for ({ skills: { [|primary|], secondary } } = multiRobot, i = 0; i < 1; i++) {
 ////    console.log(primary);
 ////}
-
-goTo.marker("1");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-
-goTo.marker("2");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.renameLocations([r0, r1], ranges);
diff --git a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts
index bef88d201d4..7d057600748 100644
--- a/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts
+++ b/tests/cases/fourslash/renameDestructuringAssignmentNestedInForOf.ts
@@ -1,22 +1,20 @@
-/// <reference path='fourslash.ts' />
-
+/// <reference path='fourslash.ts' />
+
 ////interface MultiRobot {
 ////    name: string;
 ////    skills: {
-////        /*1*/[|primary|]: string;
+////        [|primary|]: string;
 ////        secondary: string;
 ////    };
 ////}
 ////let multiRobots: MultiRobot[];
-////for ({ skills: { /*2*/[|primary|]: primaryA, secondary: secondaryA } } of multiRobots) {
+////for ({ skills: { [|primary|]: primaryA, secondary: secondaryA } } of multiRobots) {
 ////    console.log(primaryA);
 ////}
 ////for ({ skills: { [|primary|], secondary } } of multiRobots) {
 ////    console.log(primary);
 ////}
-
-goTo.marker("1");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
-
-goTo.marker("2");
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+
+const ranges = test.ranges();
+const [r0, r1] = ranges;
+verify.renameLocations([r0, r1], ranges);
diff --git a/tests/cases/fourslash/renameForDefaultExport01.ts b/tests/cases/fourslash/renameForDefaultExport01.ts
index 96f0d6e54e8..1256a9698fa 100644
--- a/tests/cases/fourslash/renameForDefaultExport01.ts
+++ b/tests/cases/fourslash/renameForDefaultExport01.ts
@@ -1,13 +1,14 @@
 /// <reference path='fourslash.ts'/>
 
-////export default class /*1*/[|DefaultExportedClass|] {
+////export default class [|DefaultExportedClass|] {
 ////}
 /////*
-//// *  Commenting [|DefaultExportedClass|]
+//// *  Commenting [|{| "inComment": true |}DefaultExportedClass|]
 //// */
 ////
-////var x: /*2*/[|DefaultExportedClass|];
+////var x: [|DefaultExportedClass|];
 ////
-////var y = new /*3*/[|DefaultExportedClass|];
+////var y = new [|DefaultExportedClass|];
 
-goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges });
diff --git a/tests/cases/fourslash/renameForDefaultExport02.ts b/tests/cases/fourslash/renameForDefaultExport02.ts
index 471b10e32b2..a6f6116ec1a 100644
--- a/tests/cases/fourslash/renameForDefaultExport02.ts
+++ b/tests/cases/fourslash/renameForDefaultExport02.ts
@@ -4,11 +4,12 @@
 ////    return /*2*/[|DefaultExportedFunction|]
 ////}
 /////**
-//// *  Commenting [|DefaultExportedFunction|]
+//// *  Commenting [|{| "inComment": true |}DefaultExportedFunction|]
 //// */
 ////
 ////var x: typeof /*3*/[|DefaultExportedFunction|];
 ////
 ////var y = /*4*/[|DefaultExportedFunction|]();
 
-goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges });
diff --git a/tests/cases/fourslash/renameForDefaultExport03.ts b/tests/cases/fourslash/renameForDefaultExport03.ts
index 1da6ff20b0b..edc22bb0db0 100644
--- a/tests/cases/fourslash/renameForDefaultExport03.ts
+++ b/tests/cases/fourslash/renameForDefaultExport03.ts
@@ -11,10 +11,11 @@
 ////var y = /*4*/[|f|]();
 ////
 /////**
-//// *  Commenting [|f|]
+//// *  Commenting [|{| "inComment": true |}f|]
 //// */
 ////namespace /*5*/[|f|] {
 ////    var local = 100;
 ////}
 
-goTo.eachMarker(() => verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true));
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges.filter(r => !(r.marker && r.marker.data.inComment)), { findInComments: true, ranges });
diff --git a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts
index 656a48f24dd..30feb0760e9 100644
--- a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts
+++ b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts
@@ -7,4 +7,11 @@
 ////import { [|{| "isWriteAccess": true, "isDefinition": true |}a|] } from './a';
 ////export { [|{| "isWriteAccess": true, "isDefinition": true |}a|] };
 
-verify.singleReferenceGroup("var a: any");
+const ranges = test.ranges();
+const [r0, r1, r2] = ranges;
+const vars = { definition: "var a: any", ranges: [r0] };
+const imports = { definition: "import a", ranges: [r1, r2] };
+verify.referenceGroups(r0, [vars, imports]);
+verify.referenceGroups(r1, [imports, vars]);
+verify.referenceGroups(r2, [imports, vars]);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportOfExportEquals.ts b/tests/cases/fourslash/renameImportOfExportEquals.ts
index 192acefd6fd..12cd86df647 100644
--- a/tests/cases/fourslash/renameImportOfExportEquals.ts
+++ b/tests/cases/fourslash/renameImportOfExportEquals.ts
@@ -1,14 +1,35 @@
 /// <reference path='fourslash.ts' />
 
-////declare namespace N {
-////    export var x: number;
+////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}N|] {
+////    export var [|{| "isWriteAccess": true, "isDefinition": true |}x|]: number;
 ////}
 ////declare module "mod" {
-////    export = N;
+////    export = [|N|];
 ////}
-////declare module "test" {
-////    import * as [|N|] from "mod";
-////    export { [|N|] }; // Renaming N here would rename
+////declare module "a" {
+////    import * as [|{| "isWriteAccess": true, "isDefinition": true |}N|] from "mod";
+////    export { [|{| "isWriteAccess": true, "isDefinition": true |}N|] }; // Renaming N here would rename
+////}
+////declare module "b" {
+////    import { [|{| "isWriteAccess": true, "isDefinition": true |}N|] } from "a";
+////    export const y: typeof [|N|].[|x|];
 ////}
 
-verify.rangesAreRenameLocations();
+const [N0, x0, N1, a0, a1, b0, b1, x1] = test.ranges();
+const nRanges = [N0, N1];
+const aRanges = [a0, a1];
+const bRanges = [b0, b1];
+const xRanges = [x0, x1];
+
+const nGroup = { definition: "namespace N", ranges: nRanges };
+const aGroup = { definition: "import N", ranges: aRanges };
+const bGroup = { definition: "import N", ranges: [b0, b1] };
+
+verify.referenceGroups(nRanges, [nGroup, aGroup, bGroup]);
+verify.referenceGroups([a0, a1], [aGroup, nGroup, bGroup]);
+verify.referenceGroups(bRanges, [bGroup, aGroup, nGroup]);
+verify.singleReferenceGroup("var N.x: number", xRanges);
+
+verify.renameLocations(nRanges, nRanges.concat(aRanges, bRanges));
+verify.rangesAreRenameLocations(aRanges.concat(bRanges));
+verify.rangesAreRenameLocations(xRanges);
diff --git a/tests/cases/fourslash/renameImportOfExportEquals2.ts b/tests/cases/fourslash/renameImportOfExportEquals2.ts
new file mode 100644
index 00000000000..f57a10c5777
--- /dev/null
+++ b/tests/cases/fourslash/renameImportOfExportEquals2.ts
@@ -0,0 +1,36 @@
+/// <reference path='fourslash.ts' />
+
+////declare namespace [|{| "isWriteAccess": true, "isDefinition": true |}N|] {
+////    export var x: number;
+////}
+////declare module "mod" {
+////    export = [|N|];
+////}
+////declare module "a" {
+////    import * as [|{| "isWriteAccess": true, "isDefinition": true |}O|] from "mod";
+////    export { [|{| "isWriteAccess": true, "isDefinition": true |}O|] as [|{| "isWriteAccess": true, "isDefinition": true |}P|] }; // Renaming N here would rename
+////}
+////declare module "b" {
+////    import { [|{| "isWriteAccess": true, "isDefinition": true |}P|] as [|{| "isWriteAccess": true, "isDefinition": true |}Q|] } from "a";
+////    export const y: typeof [|Q|].x;
+////}
+
+verify.noErrors();
+
+const [N0, N1, O0, O1, P0, P1, Q0, Q1] = test.ranges();
+const nRanges = [N0, N1];
+const oRanges = [O0, O1];
+const pRanges = [P0, P1];
+const qRanges = [Q0, Q1];
+
+const ns = { definition: "namespace N", ranges: nRanges };
+const os = { definition: "import O", ranges: oRanges };
+const ps = { definition: "import P", ranges: pRanges };
+const qs = { definition: "import Q", ranges: qRanges };
+
+verify.referenceGroups(nRanges, [ns, os, ps, qs]);
+verify.referenceGroups(oRanges, [os, ps, qs]);
+verify.referenceGroups(pRanges, [ps, qs]);
+verify.referenceGroups(qRanges, [qs]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/renameImportOfReExport.ts b/tests/cases/fourslash/renameImportOfReExport.ts
new file mode 100644
index 00000000000..3f8250b4d77
--- /dev/null
+++ b/tests/cases/fourslash/renameImportOfReExport.ts
@@ -0,0 +1,27 @@
+/// <reference path='fourslash.ts' />
+// @noLib: true
+
+////declare module "a" {
+////    export class [|{| "isWriteAccess": true, "isDefinition": true |}C|] {}
+////}
+////declare module "b" {
+////    export { [|{| "isWriteAccess": true, "isDefinition": true |}C|] } from "a";
+////}
+////declare module "c" {
+////    import { [|{| "isWriteAccess": true, "isDefinition": true |}C|] } from "b";
+////    export function f(c: [|C|]): void;
+////}
+
+verify.noErrors();
+
+verify.rangesAreRenameLocations();
+
+const ranges = test.ranges();
+const [r0, r1, r2, r3] = ranges;
+const importRanges = [r2, r3];
+const classes = { definition: "class C", ranges: [r0] };
+const bs = { definition: "import C", ranges: [r1] };
+const imports = { definition: "import C", ranges: importRanges };
+verify.referenceGroups(r0, [classes, bs, imports]);
+verify.referenceGroups(r1, [bs, imports, classes]);
+verify.referenceGroups(importRanges, [imports, bs, classes]);
diff --git a/tests/cases/fourslash/renameImportOfReExport2.ts b/tests/cases/fourslash/renameImportOfReExport2.ts
new file mode 100644
index 00000000000..56cc3966112
--- /dev/null
+++ b/tests/cases/fourslash/renameImportOfReExport2.ts
@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+////declare module "a" {
+////    export class [|{| "isWriteAccess": true, "isDefinition": true |}C|] {}
+////}
+////declare module "b" {
+////    export { [|{| "isWriteAccess": true, "isDefinition": true |}C|] as [|{| "isWriteAccess": true, "isDefinition": true |}D|] } from "a";
+////}
+////declare module "c" {
+////    import { [|{| "isWriteAccess": true, "isDefinition": true |}D|] } from "b";
+////    export function f(c: [|D|]): void;
+////}
+
+verify.noErrors();
+
+const ranges = test.rangesByText();
+const cRanges = ranges.get("C");
+const [d0, d1, d2] = ranges.get("D");
+
+const classes = { definition: "class C", ranges: cRanges };
+const bImports = { definition: "import D", ranges: [d0] };
+const cImports = { definition: "import D", ranges: [d1, d2] };
+verify.referenceGroups(cRanges, [classes, bImports, cImports]);
+
+verify.referenceGroups(d0, [bImports, cImports]);
+verify.referenceGroups([d1, d2], [cImports, bImports]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsExports01.ts b/tests/cases/fourslash/renameJsExports01.ts
index 923d30eedf9..b731ece63f3 100644
--- a/tests/cases/fourslash/renameJsExports01.ts
+++ b/tests/cases/fourslash/renameJsExports01.ts
@@ -8,5 +8,5 @@
 ////var mod = require('./a');
 ////var t = mod./**/[|area|](10);
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.singleReferenceGroup("(property) area: (r: any) => number");
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsExports02.ts b/tests/cases/fourslash/renameJsExports02.ts
index 86b0471dc1f..94c84980784 100644
--- a/tests/cases/fourslash/renameJsExports02.ts
+++ b/tests/cases/fourslash/renameJsExports02.ts
@@ -1,12 +1,16 @@
-/// <reference path='fourslash.ts'/>
-
-// @allowJs: true
-// @Filename: a.js
-////exports./**/[|area|] = function (r) { return r * r; }
-
-// @Filename: b.js
-////var mod = require('./a');
-////var t = mod.[|area|](10);
-
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+/// <reference path='fourslash.ts'/>
+
+// @allowJs: true
+// @Filename: a.js
+////module.exports = class [|{| "isWriteAccess": true, "isDefinition": true |}A|] {}
+
+// @Filename: b.js
+////const [|{| "isWriteAccess": true, "isDefinition": true |}A|] = require("./a");
+
+const [r0, r1] = test.ranges();
+verify.referenceGroups(r0, [
+    { definition: "(local class) A", ranges: [r0] },
+    { definition: "const A: typeof A", ranges: [r1] }
+]);
+
+verify.singleReferenceGroup("const A: typeof A", [r1]);
diff --git a/tests/cases/fourslash/renameJsExports03.ts b/tests/cases/fourslash/renameJsExports03.ts
new file mode 100644
index 00000000000..0ffd4d04692
--- /dev/null
+++ b/tests/cases/fourslash/renameJsExports03.ts
@@ -0,0 +1,31 @@
+/// <reference path='fourslash.ts'/>
+
+// @allowJs: true
+// @Filename: a.js
+////class [|{| "isWriteAccess": true, "isDefinition": true |}A|] {
+////    [|constructor|]() { }
+////}
+////module.exports = [|A|];
+
+// @Filename: b.js
+////const [|{| "isWriteAccess": true, "isDefinition": true |}A|] = require("./a");
+////new [|A|];
+
+const [r0, r1, r2, r3, r4] = test.ranges();
+verify.referenceGroups([r0, r2], [
+    { definition: "class A", ranges: [r0, r2] },
+    { definition: "const A: typeof A", ranges: [r3, r4] }
+]);
+
+verify.referenceGroups(r1, [
+    { definition: "constructor A(): A", ranges: [r1] },
+    { definition: "const A: typeof A", ranges: [r4] }
+]);
+
+verify.referenceGroups(r3, [
+    { definition: "const A: typeof A", ranges: [r3, r4] }
+]);
+verify.referenceGroups(r4, [
+    { definition: "const A: new () => A", ranges: [r3, r4] }
+]);
+
diff --git a/tests/cases/fourslash/renameJsPropertyAssignment.ts b/tests/cases/fourslash/renameJsPropertyAssignment.ts
index fd1ba47569d..87daae544e1 100644
--- a/tests/cases/fourslash/renameJsPropertyAssignment.ts
+++ b/tests/cases/fourslash/renameJsPropertyAssignment.ts
@@ -5,7 +5,6 @@
 ////function bar() {
 ////}
 ////bar.[|foo|] = "foo";
-////console.log(bar./**/[|foo|]);
+////console.log(bar.[|foo|]);
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsPropertyAssignment2.ts b/tests/cases/fourslash/renameJsPropertyAssignment2.ts
index 39831d4ae1b..eaea2b9aa27 100644
--- a/tests/cases/fourslash/renameJsPropertyAssignment2.ts
+++ b/tests/cases/fourslash/renameJsPropertyAssignment2.ts
@@ -5,7 +5,6 @@
 ////class Minimatch {
 ////}
 ////Minimatch.[|staticProperty|] = "string";
-////console.log(Minimatch./**/[|staticProperty|]);
+////console.log(Minimatch.[|staticProperty|]);
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsPropertyAssignment3.ts b/tests/cases/fourslash/renameJsPropertyAssignment3.ts
index 5871010d6f4..cedf69c7eee 100644
--- a/tests/cases/fourslash/renameJsPropertyAssignment3.ts
+++ b/tests/cases/fourslash/renameJsPropertyAssignment3.ts
@@ -5,7 +5,6 @@
 ////var C = class  {
 ////}
 ////C.[|staticProperty|] = "string";
-////console.log(C./**/[|staticProperty|]);
+////console.log(C.[|staticProperty|]);
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsPrototypeProperty01.ts b/tests/cases/fourslash/renameJsPrototypeProperty01.ts
index f756f57edbf..1700f15619d 100644
--- a/tests/cases/fourslash/renameJsPrototypeProperty01.ts
+++ b/tests/cases/fourslash/renameJsPrototypeProperty01.ts
@@ -6,7 +6,6 @@
 ////}
 ////bar.prototype.[|x|] = 10;
 ////var t = new bar();
-////t./**/[|x|] = 11;
+////t.[|x|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsPrototypeProperty02.ts b/tests/cases/fourslash/renameJsPrototypeProperty02.ts
index 721dc312eb6..1700f15619d 100644
--- a/tests/cases/fourslash/renameJsPrototypeProperty02.ts
+++ b/tests/cases/fourslash/renameJsPrototypeProperty02.ts
@@ -4,9 +4,8 @@
 // @Filename: a.js
 ////function bar() {
 ////}
-////bar.prototype./**/[|x|] = 10;
+////bar.prototype.[|x|] = 10;
 ////var t = new bar();
 ////t.[|x|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts b/tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts
index b4b9fb80528..013cfe34cd5 100644
--- a/tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts
+++ b/tests/cases/fourslash/renameJsSpecialAssignmentRhs1.ts
@@ -6,8 +6,8 @@
 ////        this._x = x;
 ////    },
 ////    copy: function ([|x|]) {
-////        this._x = /**/[|x|].prop;
+////        this._x = [|x|].prop;
 ////    }
 ////};
-goTo.marker();
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts b/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts
index 5b4b6e851cf..013cfe34cd5 100644
--- a/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts
+++ b/tests/cases/fourslash/renameJsSpecialAssignmentRhs2.ts
@@ -5,9 +5,9 @@
 ////    set: function (x) {
 ////        this._x = x;
 ////    },
-////    copy: function (/**/[|x|]) {
+////    copy: function ([|x|]) {
 ////        this._x = [|x|].prop;
 ////    }
 ////};
-goTo.marker();
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsThisProperty01.ts b/tests/cases/fourslash/renameJsThisProperty01.ts
index 91338e0431d..5680dbf08fd 100644
--- a/tests/cases/fourslash/renameJsThisProperty01.ts
+++ b/tests/cases/fourslash/renameJsThisProperty01.ts
@@ -6,7 +6,6 @@
 ////    this.[|x|] = 10;
 ////}
 ////var t = new bar();
-////t./**/[|x|] = 11;
+////t.[|x|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsThisProperty02.ts b/tests/cases/fourslash/renameJsThisProperty02.ts
deleted file mode 100644
index 8398507c9ca..00000000000
--- a/tests/cases/fourslash/renameJsThisProperty02.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-// @allowJs: true
-// @Filename: a.js
-////function bar() {
-////    this./**/[|x|] = 10;
-////}
-////var t = new bar();
-////t.[|x|] = 11;
-
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
\ No newline at end of file
diff --git a/tests/cases/fourslash/renameJsThisProperty03.ts b/tests/cases/fourslash/renameJsThisProperty03.ts
index f2176538578..8633c61132c 100644
--- a/tests/cases/fourslash/renameJsThisProperty03.ts
+++ b/tests/cases/fourslash/renameJsThisProperty03.ts
@@ -4,11 +4,10 @@
 // @Filename: a.js
 ////class C {
 ////  constructor(y) {
-////    this./**/[|x|] = y;
+////    this.[|x|] = y;
 ////  }
 ////}
 ////var t = new C(12);
 ////t.[|x|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsThisProperty04.ts b/tests/cases/fourslash/renameJsThisProperty04.ts
deleted file mode 100644
index e307022c66f..00000000000
--- a/tests/cases/fourslash/renameJsThisProperty04.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-/// <reference path='fourslash.ts'/>
-
-// @allowJs: true
-// @Filename: a.js
-////class C {
-////  constructor(y) {
-////    this.[|x|] = y;
-////  }
-////}
-////var t = new C(12);
-////t./**/[|x|] = 11;
-
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
diff --git a/tests/cases/fourslash/renameJsThisProperty05.ts b/tests/cases/fourslash/renameJsThisProperty05.ts
index c1408d6aff1..861919ec777 100644
--- a/tests/cases/fourslash/renameJsThisProperty05.ts
+++ b/tests/cases/fourslash/renameJsThisProperty05.ts
@@ -9,7 +9,6 @@
 ////}
 ////C.prototype.[|z|] = 1;
 ////var t = new C(12);
-////t./**/[|z|] = 11;
+////t.[|z|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameJsThisProperty06.ts b/tests/cases/fourslash/renameJsThisProperty06.ts
index 63a16b68a4f..7269a50f4f0 100644
--- a/tests/cases/fourslash/renameJsThisProperty06.ts
+++ b/tests/cases/fourslash/renameJsThisProperty06.ts
@@ -9,7 +9,6 @@
 ////}
 ////C.prototype.[|z|] = 1;
 ////var t = new C(12);
-////t./**/[|z|] = 11;
+////t.[|z|] = 11;
 
-goTo.marker();
-verify.renameLocations( /*findInStrings*/ false, /*findInComments*/ false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/renameModuleToVar.ts b/tests/cases/fourslash/renameModuleToVar.ts
index fc31f4040e8..8f01f909c83 100644
--- a/tests/cases/fourslash/renameModuleToVar.ts
+++ b/tests/cases/fourslash/renameModuleToVar.ts
@@ -13,4 +13,4 @@
 goTo.marker();
 edit.backspace(6);
 edit.insert("var");
-verify.numberOfErrorsInCurrentFile(0);
+verify.noErrors();
diff --git a/tests/cases/fourslash/renameObjectSpread.ts b/tests/cases/fourslash/renameObjectSpread.ts
index f56c22dd42f..f3af6e0280f 100644
--- a/tests/cases/fourslash/renameObjectSpread.ts
+++ b/tests/cases/fourslash/renameObjectSpread.ts
@@ -6,15 +6,11 @@
 ////let a2: A2;
 ////let a12 = { ...a1, ...a2 };
 ////a12.[|a|];
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
 
+const [r0, r1, r2] = test.ranges();
 // A1 unions with A2, so rename A1.a and a12.a
-goTo.rangeStart(ranges[0]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
+verify.renameLocations(r0, [r0, r2]);
 // A1 unions with A2, so rename A2.a and a12.a
-goTo.rangeStart(ranges[1]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[2]]);
+verify.renameLocations(r1, [r1, r2]);
 // a12.a unions A1.a and A2.a, so rename A1.a, A2.a and a12.a
-goTo.rangeStart(ranges[2]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[1], ranges[2]]);
+verify.renameLocations(r2, [r0, r1, r2]);
diff --git a/tests/cases/fourslash/renameObjectSpreadAssignment.ts b/tests/cases/fourslash/renameObjectSpreadAssignment.ts
index 2ddebb6e18b..9d55e43afa5 100644
--- a/tests/cases/fourslash/renameObjectSpreadAssignment.ts
+++ b/tests/cases/fourslash/renameObjectSpreadAssignment.ts
@@ -6,17 +6,6 @@
 ////let [|a2|]: A2;
 ////let a12 = { ...[|a1|], ...[|a2|] };
 
-const ranges = test.ranges();
-verify.assertHasRanges(ranges);
-
-
-// rename a1
-goTo.rangeStart(ranges[0]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
-goTo.rangeStart(ranges[2]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[0], ranges[2]]);
-// rename a2
-goTo.rangeStart(ranges[1]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]);
-goTo.rangeStart(ranges[3]);
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [ranges[1], ranges[3]]);
+const [r0, r1, r2, r3] = test.ranges();
+verify.rangesAreRenameLocations([r0, r2]);
+verify.rangesAreRenameLocations([r1, r3]);
diff --git a/tests/cases/fourslash/renameStingPropertyNames.ts b/tests/cases/fourslash/renameStringPropertyNames.ts
similarity index 100%
rename from tests/cases/fourslash/renameStingPropertyNames.ts
rename to tests/cases/fourslash/renameStringPropertyNames.ts
diff --git a/tests/cases/fourslash/renameThis.ts b/tests/cases/fourslash/renameThis.ts
index c4e5d932261..e626294bf46 100644
--- a/tests/cases/fourslash/renameThis.ts
+++ b/tests/cases/fourslash/renameThis.ts
@@ -6,17 +6,12 @@
 ////this/**/;
 ////const _ = { [|this|]: 0 }.[|this|];
 
-let [r0, r1, r2, r3] = test.ranges()
-for (let range of [r0, r1]) {
-    goTo.rangeStart(range);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r0, r1]);
-}
+const [r0, r1, r2, r3] = test.ranges()
+verify.rangesAreRenameLocations([r0, r1]);
 
 // Trying to rename a non-parameter 'this' should fail
 goTo.marker();
 verify.renameInfoFailed("You cannot rename this element.");
 
-for (let range of [r2, r3]) {
-    goTo.rangeStart(range);
-    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false, [r2, r3]);
-}
+verify.rangesAreRenameLocations([r2, r3]);
+
diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts
index 776d0180b06..38a35b58cbf 100644
--- a/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts
+++ b/tests/cases/fourslash/server/jsdocTypedefTagRename01.ts
@@ -4,17 +4,11 @@
 // @Filename: jsDocTypedef_form1.js
 ////
 //// /** @typedef {(string | number)} */
-//// var /*1*/[|NumberLike|];
+//// var [|NumberLike|];
 ////
-//// /*2*/[|NumberLike|] = 10;
+//// [|NumberLike|] = 10;
 ////
-//// /** @type {/*3*/[|NumberLike|]} */
+//// /** @type {[|NumberLike|]} */
 //// var numberLike;
 
-goTo.file('jsDocTypedef_form1.js')
-goTo.marker('1');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-goTo.marker('2');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-goTo.marker('3');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
\ No newline at end of file
+verify.rangesAreRenameLocations({ findInComments: true });
diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts
index 7f1d422d971..38da754247f 100644
--- a/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts
+++ b/tests/cases/fourslash/server/jsdocTypedefTagRename02.ts
@@ -3,13 +3,9 @@
 // @allowNonTsExtensions: true
 // @Filename: jsDocTypedef_form2.js
 ////
-//// /** @typedef {(string | number)} /*1*/[|NumberLike|] */
+//// /** @typedef {(string | number)} [|NumberLike|] */
 ////
-//// /** @type {/*2*/[|NumberLike|]} */
+//// /** @type {[|NumberLike|]} */
 //// var numberLike;
 
-goTo.file('jsDocTypedef_form2.js')
-goTo.marker('1');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-goTo.marker('2');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
\ No newline at end of file
+verify.rangesAreRenameLocations({ findInComments: true });
diff --git a/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts b/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts
index c1b38945806..7b61682e594 100644
--- a/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts
+++ b/tests/cases/fourslash/server/jsdocTypedefTagRename03.ts
@@ -3,7 +3,7 @@
 // @allowNonTsExtensions: true
 // @Filename: jsDocTypedef_form3.js
 ////
-//// /** 
+//// /**
 ////  * @typedef /*1*/[|Person|]
 ////  * @type {Object}
 ////  * @property {number} age
@@ -14,7 +14,4 @@
 //// var person;
 
 goTo.file('jsDocTypedef_form3.js')
-goTo.marker('1');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
-goTo.marker('2');
-verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ true);
\ No newline at end of file
+verify.rangesAreRenameLocations({ findInComments: true });
diff --git a/tests/cases/fourslash/server/rename01.ts b/tests/cases/fourslash/server/rename01.ts
index 2da25f87ba7..74385c30da3 100644
--- a/tests/cases/fourslash/server/rename01.ts
+++ b/tests/cases/fourslash/server/rename01.ts
@@ -1,11 +1,11 @@
 /// <reference path="../fourslash.ts"/>
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to [|Bar|] in a comment.
 ////    "this is a reference to [|Bar|] in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true);
\ No newline at end of file
+const ranges = test.ranges();
+verify.renameLocations(ranges[0], { findInStrings: true, findInComments: true, ranges });
diff --git a/tests/cases/fourslash/server/renameInConfiguredProject.ts b/tests/cases/fourslash/server/renameInConfiguredProject.ts
index ecff87493a8..a235f783f4c 100644
--- a/tests/cases/fourslash/server/renameInConfiguredProject.ts
+++ b/tests/cases/fourslash/server/renameInConfiguredProject.ts
@@ -4,10 +4,9 @@
 ////var [|globalName|] = 0;
 
 // @Filename: referencesForGlobals_2.ts
-////var y = /*1*/[|globalName|];
+////var y = [|globalName|];
 
 // @Filename: tsconfig.json
 ////{ "files": ["referencesForGlobals_1.ts", "referencesForGlobals_2.ts"] }
 
-goTo.marker("1");
-verify.renameLocations(/*findInStrings:*/ true, /*findInComments:*/ true);
+verify.rangesAreRenameLocations({ findInStrings: true, findInComments: true });
diff --git a/tests/cases/fourslash/shims-pp/getRenameInfo.ts b/tests/cases/fourslash/shims-pp/getRenameInfo.ts
index b7a1f5d61ae..aa04d69962a 100644
--- a/tests/cases/fourslash/shims-pp/getRenameInfo.ts
+++ b/tests/cases/fourslash/shims-pp/getRenameInfo.ts
@@ -1,11 +1,10 @@
-/// <reference path="fourslash.ts" />
+/// <reference path="../fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to Bar in a comment.
 ////    "this is a reference to Bar in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/shims/getRenameInfo.ts b/tests/cases/fourslash/shims/getRenameInfo.ts
index b7a1f5d61ae..aa04d69962a 100644
--- a/tests/cases/fourslash/shims/getRenameInfo.ts
+++ b/tests/cases/fourslash/shims/getRenameInfo.ts
@@ -1,11 +1,10 @@
-/// <reference path="fourslash.ts" />
+/// <reference path="../fourslash.ts" />
 
-///////<reference path="./Bar.ts" /> 
+///////<reference path="./Bar.ts" />
 
-////function /**/[|Bar|]() {
+////function [|Bar|]() {
 ////    // This is a reference to Bar in a comment.
 ////    "this is a reference to Bar in a string"
 ////}
 
-goTo.marker();
-verify.renameLocations(/*findInStrings:*/ false, /*findInComments:*/ false);
\ No newline at end of file
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts b/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts
index ddada820ee0..be381c764f3 100644
--- a/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts
+++ b/tests/cases/fourslash/superInDerivedTypeOfGenericWithStatics.ts
@@ -2,7 +2,7 @@
 
 ////module M {
 ////   export class C<T extends Date> {
-////      static foo(): C<Date> { 
+////      static foo(): C<Date> {
 ////          return null;
 ////           }
 ////     }
@@ -15,4 +15,4 @@
 
 goTo.marker();
 edit.insert('super();');
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
\ No newline at end of file
diff --git a/tests/cases/fourslash/transitiveExportImports.ts b/tests/cases/fourslash/transitiveExportImports.ts
index 6ac905f017d..093121c1d9e 100644
--- a/tests/cases/fourslash/transitiveExportImports.ts
+++ b/tests/cases/fourslash/transitiveExportImports.ts
@@ -1,17 +1,36 @@
 /// <reference path='fourslash.ts'/>
 
 // @Filename: a.ts
-////class A {
+////class [|{| "isWriteAccess": true, "isDefinition": true |}A|] {
 ////}
-////export = A;
+////export = [|A|];
 
 // @Filename: b.ts
-////export import a = require('./a');
+////export import [|{| "isWriteAccess": true, "isDefinition": true |}b|] = require('./a');
 
 // @Filename: c.ts
-////import b = require('./b');
-////var a = new b./**/a();
+////import [|{| "isWriteAccess": true, "isDefinition": true |}b|] = require('./b');
+////var a = new [|b|]./**/[|b|]();
 
 goTo.marker();
 verify.quickInfoExists();
-verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
+verify.noErrors();
+
+const [a0, a1, b0, c0, c1, c2] = test.ranges();
+const aRanges = [a0, a1];
+const bRanges = [b0, c2];
+const cRanges = [c0, c1];
+
+const bGroup = { definition: "import b = require('./a')", ranges: bRanges }
+
+verify.referenceGroups(aRanges, [
+    { definition: "class A", ranges: aRanges },
+    bGroup
+]);
+verify.referenceGroups(b0, [bGroup]);
+verify.referenceGroups(c2, [{ ...bGroup, definition: "(alias) new b.b(): b.b\nimport b.b = require('./a')"}]);
+verify.singleReferenceGroup("import b = require('./b')", cRanges);
+
+verify.rangesAreRenameLocations(aRanges);
+verify.rangesAreRenameLocations(bRanges);
+verify.rangesAreRenameLocations(cRanges);
diff --git a/tests/cases/fourslash/transitiveExportImports2.ts b/tests/cases/fourslash/transitiveExportImports2.ts
new file mode 100644
index 00000000000..397bbf44a37
--- /dev/null
+++ b/tests/cases/fourslash/transitiveExportImports2.ts
@@ -0,0 +1,30 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////namespace [|{| "isWriteAccess": true, "isDefinition": true |}A|] {
+////    export const x = 0;
+////}
+
+// @Filename: b.ts
+////export import [|{| "isWriteAccess": true, "isDefinition": true |}B|] = [|A|];
+////[|B|].x;
+
+// @Filename: c.ts
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}B|] } from "./b";
+
+verify.noErrors();
+
+const [A0, B0, A1, B1, B2] = test.ranges();
+const aRanges = [A0, A1];
+const bRanges = [B0, B1];
+const cRanges = [B2];
+
+const aGroup = { definition: "namespace A", ranges: aRanges };
+const bGroup = { definition: "import B = A", ranges: bRanges };
+const cGroup = { definition: "import B", ranges: cRanges };
+
+verify.referenceGroups(aRanges, [aGroup, bGroup, cGroup]);
+verify.referenceGroups(bRanges, [bGroup, cGroup]);
+verify.referenceGroups(cRanges, [cGroup, bGroup]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/transitiveExportImports3.ts b/tests/cases/fourslash/transitiveExportImports3.ts
new file mode 100644
index 00000000000..6b3bb10572d
--- /dev/null
+++ b/tests/cases/fourslash/transitiveExportImports3.ts
@@ -0,0 +1,25 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////export function [|{| "isWriteAccess": true, "isDefinition": true |}f|]() {}
+
+// @Filename: b.ts
+////export { [|{| "isWriteAccess": true, "isDefinition": true |}f|] as [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./a";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}f|] } from "./a";
+////import { [|{| "isWriteAccess": true, "isDefinition": true |}g|] } from "./b";
+
+verify.noErrors();
+
+const [f0, f1, g0, f2, g1] = test.ranges();
+
+const af = { definition: "function f(): void", ranges: [f0, f1] };
+const g0Group = { definition: "import g", ranges: [g0] };
+const g1Group = { definition: "import g", ranges: [g1] };
+const bf = { definition: "import f", ranges: [f2] };
+
+verify.referenceGroups([f0, f1], [af, g0Group, g1Group, bf]);
+verify.referenceGroups(g0, [g0Group, g1Group]);
+verify.referenceGroups(g1, [g1Group, g0Group]);
+verify.referenceGroups(f2, [bf, af, g0Group, g1Group]);
+
+verify.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename1.ts b/tests/cases/fourslash/tsxRename1.ts
index 3fb973ec996..4323e99df59 100644
--- a/tests/cases/fourslash/tsxRename1.ts
+++ b/tests/cases/fourslash/tsxRename1.ts
@@ -11,7 +11,6 @@
 ////         span: { n: string; };
 ////     }
 //// }
-//// var x = <[|di/*ds*/v|] />;
+//// var x = <[|div|] />;
 
-goTo.marker('ds');
-verify.renameLocations(false, false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename10.ts b/tests/cases/fourslash/tsxRename10.ts
deleted file mode 100644
index 091f5aa976f..00000000000
--- a/tests/cases/fourslash/tsxRename10.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-//@Filename: file.tsx
-// @jsx: preserve
-// @noLib: true
-
-//// declare module JSX {
-////     interface Element { }
-////     interface IntrinsicElements {
-////     }
-////     interface ElementAttributesProperty { props; }
-//// }
-//// interface ClickableProps {
-////     children?: string;
-////     className?: string;
-//// }
-//// interface ButtonProps extends ClickableProps {
-////     onClick(event?: React.MouseEvent<HTMLButtonElement>): void;
-//// }
-//// interface LinkProps extends ClickableProps {
-////     [|goTo|]: string;
-//// }
-//// declare function MainButton(buttonProps: ButtonProps): JSX.Element;
-//// declare function MainButton(linkProps: LinkProps): JSX.Element;
-//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element;
-//// let opt = <MainButton />;
-//// let opt = <MainButton children="chidlren" />;
-//// let opt = <MainButton onClick={()=>{}} />;
-//// let opt = <MainButton onClick={()=>{}} ignore-prop />;
-//// let opt = <MainButton [|goTo|]="goTo" />;
-//// let opt = <MainButton [|goTo|] />;
-//// let opt = <MainButton wrong />;
-
-
-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
diff --git a/tests/cases/fourslash/tsxRename11.ts b/tests/cases/fourslash/tsxRename11.ts
deleted file mode 100644
index 97933dd0cc9..00000000000
--- a/tests/cases/fourslash/tsxRename11.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-//@Filename: file.tsx
-// @jsx: preserve
-// @noLib: true
-
-//// declare module JSX {
-////     interface Element { }
-////     interface IntrinsicElements {
-////     }
-////     interface ElementAttributesProperty { props; }
-//// }
-//// interface ClickableProps {
-////     children?: string;
-////     className?: string;
-//// }
-//// interface ButtonProps extends ClickableProps {
-////     [|onClick|](event?: React.MouseEvent<HTMLButtonElement>): void;
-//// }
-//// interface LinkProps extends ClickableProps {
-////     goTo: string;
-//// }
-//// declare function MainButton(buttonProps: ButtonProps): JSX.Element;
-//// declare function MainButton(linkProps: LinkProps): JSX.Element;
-//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element;
-//// let opt = <MainButton />;
-//// let opt = <MainButton children="chidlren" />;
-//// let opt = <MainButton [|onClick|]={()=>{}} />;
-//// let opt = <MainButton [|onClick|]={()=>{}} ignore-prop />;
-//// let opt = <MainButton goTo="goTo" />;
-//// let opt = <MainButton wrong />;
-
-
-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
diff --git a/tests/cases/fourslash/tsxRename12.ts b/tests/cases/fourslash/tsxRename12.ts
deleted file mode 100644
index 30e6b506f4d..00000000000
--- a/tests/cases/fourslash/tsxRename12.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-//@Filename: file.tsx
-// @jsx: preserve
-// @noLib: true
-
-//// declare module JSX {
-////     interface Element { }
-////     interface IntrinsicElements {
-////     }
-////     interface ElementAttributesProperty { props; }
-//// }
-//// interface ClickableProps {
-////     children?: string;
-////     className?: string;
-//// }
-//// interface ButtonProps extends ClickableProps {
-////     onClick(event?: React.MouseEvent<HTMLButtonElement>): void;
-//// }
-//// interface LinkProps extends ClickableProps {
-////     goTo: string;
-//// }
-//// declare function MainButton(buttonProps: ButtonProps): JSX.Element;
-//// declare function MainButton(linkProps: LinkProps): JSX.Element;
-//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element;
-//// let opt = <MainButton />;
-//// let opt = <MainButton children="chidlren" />;
-//// let opt = <MainButton onClick={()=>{}} />;
-//// let opt = <MainButton onClick={()=>{}} ignore-prop />;
-//// let opt = <MainButton goTo="goTo" />;
-//// let opt = <MainButton [|wrong|] />;
-
-
-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
diff --git a/tests/cases/fourslash/tsxRename13.ts b/tests/cases/fourslash/tsxRename13.ts
deleted file mode 100644
index 02d0fb1b3dd..00000000000
--- a/tests/cases/fourslash/tsxRename13.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-//@Filename: file.tsx
-// @jsx: preserve
-// @noLib: true
-
-//// declare module JSX {
-////     interface Element { }
-////     interface IntrinsicElements {
-////     }
-////     interface ElementAttributesProperty { props; }
-//// }
-//// interface ClickableProps {
-////     children?: string;
-////     className?: string;
-//// }
-//// interface ButtonProps extends ClickableProps {
-////     onClick(event?: React.MouseEvent<HTMLButtonElement>): void;
-//// }
-//// interface LinkProps extends ClickableProps {
-////     goTo: string;
-//// }
-//// declare function MainButton(buttonProps: ButtonProps): JSX.Element;
-//// declare function MainButton(linkProps: LinkProps): JSX.Element;
-//// declare function MainButton(props: ButtonProps | LinkProps): JSX.Element;
-//// let opt = <MainButton />;
-//// let opt = <MainButton children="chidlren" />;
-//// let opt = <MainButton onClick={()=>{}} />;
-//// let opt = <MainButton onClick={()=>{}} [|ignore-prop|] />;
-//// let opt = <MainButton goTo="goTo" />;
-//// let opt = <MainButton wrong />;
-
-
-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
diff --git a/tests/cases/fourslash/tsxRename2.ts b/tests/cases/fourslash/tsxRename2.ts
index d0f5737214b..e5e0688150c 100644
--- a/tests/cases/fourslash/tsxRename2.ts
+++ b/tests/cases/fourslash/tsxRename2.ts
@@ -11,7 +11,6 @@
 ////         span: { n: string; };
 ////     }
 //// }
-//// var x = <div [|na/**/me|]="hello" />;
+//// var x = <div [|name|]="hello" />;
 
-goTo.marker();
-verify.renameLocations(false, false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename3.ts b/tests/cases/fourslash/tsxRename3.ts
index 1ab9c8a5915..b997ea2fdca 100644
--- a/tests/cases/fourslash/tsxRename3.ts
+++ b/tests/cases/fourslash/tsxRename3.ts
@@ -12,9 +12,8 @@
 ////     [|name|]?: string;
 ////     size?: number;
 //// }
-//// 
-//// 
-//// var x = <MyClass [|n/**/ame|]='hello'/>;
+////
+////
+//// var x = <MyClass [|name|]='hello'/>;
 
-goTo.marker();
-verify.renameLocations(false, false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename4.ts b/tests/cases/fourslash/tsxRename4.ts
index baaa31bdc4d..a7e57cca258 100644
--- a/tests/cases/fourslash/tsxRename4.ts
+++ b/tests/cases/fourslash/tsxRename4.ts
@@ -12,9 +12,8 @@
 ////     name?: string;
 ////     size?: number;
 //// }
-//// 
-//// 
-//// var x = <[|MyC/**/lass|] name='hello'></[|MyClass|]>;
+////
+////
+//// var x = <[|MyClass|] name='hello'></[|MyClass|]>;
 
-goTo.marker();
-verify.renameLocations(false, false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename5.ts b/tests/cases/fourslash/tsxRename5.ts
index cc18d6287c3..a4c70b4b1c3 100644
--- a/tests/cases/fourslash/tsxRename5.ts
+++ b/tests/cases/fourslash/tsxRename5.ts
@@ -12,9 +12,8 @@
 ////     name?: string;
 ////     size?: number;
 //// }
-//// 
+////
 //// var [|nn|]: string;
-//// var x = <MyClass name={[|n/**/n|]}></MyClass>;
+//// var x = <MyClass name={[|nn|]}></MyClass>;
 
-goTo.marker();
-verify.renameLocations(false, false);
+verify.rangesAreRenameLocations();
diff --git a/tests/cases/fourslash/tsxRename6.ts b/tests/cases/fourslash/tsxRename6.ts
index 59bc3f48009..6f999c12760 100644
--- a/tests/cases/fourslash/tsxRename6.ts
+++ b/tests/cases/fourslash/tsxRename6.ts
@@ -22,9 +22,4 @@
 //// let opt3 = <[|Opt|] wrong />;
 //// let opt4 = <[|Opt|] propx={100} propString="hi" />;
 
-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/tsxRename7.ts b/tests/cases/fourslash/tsxRename7.ts
index b5d05e49bd3..5533db1b4db 100644
--- a/tests/cases/fourslash/tsxRename7.ts
+++ b/tests/cases/fourslash/tsxRename7.ts
@@ -21,9 +21,4 @@
 //// let opt2 = <Opt [|propx|]={100} optional/>;
 //// let opt3 = <Opt wrong />;
 
-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/tsxRename8.ts b/tests/cases/fourslash/tsxRename8.ts
index 48bbff0d88e..a75c2833bb2 100644
--- a/tests/cases/fourslash/tsxRename8.ts
+++ b/tests/cases/fourslash/tsxRename8.ts
@@ -23,9 +23,4 @@
 //// let opt3 = <Opt [|wrong|] />;
 //// let opt4 = <Opt propx={100} propString="hi" />;
 
-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/tsxRename9.ts b/tests/cases/fourslash/tsxRename9.ts
index 4d132f5eac9..b39b009634d 100644
--- a/tests/cases/fourslash/tsxRename9.ts
+++ b/tests/cases/fourslash/tsxRename9.ts
@@ -15,24 +15,19 @@
 ////     className?: string;
 //// }
 //// interface ButtonProps extends ClickableProps {
-////     onClick(event?: React.MouseEvent<HTMLButtonElement>): void;
+////     [|onClick|](event?: React.MouseEvent<HTMLButtonElement>): void;
 //// }
 //// interface LinkProps extends ClickableProps {
-////     goTo: string;
+////     [|goTo|]: string;
 //// }
 //// declare function [|MainButton|](buttonProps: ButtonProps): JSX.Element;
 //// declare function [|MainButton|](linkProps: LinkProps): JSX.Element;
 //// declare function [|MainButton|](props: ButtonProps | LinkProps): JSX.Element;
 //// let opt = <[|MainButton|] />;
 //// let opt = <[|MainButton|] children="chidlren" />;
-//// let opt = <[|MainButton|] onClick={()=>{}} />;
-//// let opt = <[|MainButton|] onClick={()=>{}} ignore-prop />;
-//// let opt = <[|MainButton|] goTo="goTo" />;
-//// let opt = <[|MainButton|] wrong />;
+//// let opt = <[|MainButton|] [|onClick|]={()=>{}} />;
+//// let opt = <[|MainButton|] [|onClick|]={()=>{}} [|ignore-prop|] />;
+//// let opt = <[|MainButton|] [|goTo|]="goTo" />;
+//// let opt = <[|MainButton|] [|wrong|] />;
 
-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.rangesWithSameTextAreRenameLocations();
diff --git a/tests/cases/fourslash/untypedModuleImport.ts b/tests/cases/fourslash/untypedModuleImport.ts
index 1854010d5b6..4dac6ac76bb 100644
--- a/tests/cases/fourslash/untypedModuleImport.ts
+++ b/tests/cases/fourslash/untypedModuleImport.ts
@@ -4,7 +4,7 @@
 ////{}
 
 // @Filename: a.ts
-////import /*foo*/[|{| "isWriteAccess": true, "isDefinition": true |}foo|] from /*fooModule*/"foo";
+////import /*foo*/[|{| "isWriteAccess": true, "isDefinition": true |}foo|] from /*fooModule*/"[|{| "isInString": true |}foo|]";
 ////[|foo|]();
 
 goTo.file("a.ts");
@@ -13,9 +13,10 @@ verify.numberOfErrorsInCurrentFile(0);
 goTo.marker("fooModule");
 verify.goToDefinitionIs([]);
 verify.quickInfoIs("");
-verify.noReferences();
+const [r0, r1, r2] = test.ranges();
+verify.singleReferenceGroup('"foo"', [r1]);
 
 goTo.marker("foo");
 verify.goToDefinitionIs([]);
 verify.quickInfoIs("import foo");
-verify.singleReferenceGroup("import foo");
+verify.singleReferenceGroup("import foo", [r0, r2]);