diff --git a/Jakefile.js b/Jakefile.js
index f1a714c1e26..439fced0720 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -268,7 +268,6 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
     * @param {boolean} opts.preserveConstEnums: true if compiler should keep const enums in code
     * @param {boolean} opts.noResolve: true if compiler should not include non-rooted files in compilation
     * @param {boolean} opts.stripInternal: true if compiler should remove declarations marked as @internal
-    * @param {boolean} opts.noMapRoot: true if compiler omit mapRoot option
     * @param {boolean} opts.inlineSourceMap: true if compiler should inline sourceMap
     * @param {Array} opts.types: array of types to include in compilation
     * @param callback: a function to execute after the compilation process ends
@@ -321,9 +320,6 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
             }
             else {
                 options += " -sourcemap";
-                if (!opts.noMapRoot) {
-                    options += " -mapRoot file:///" + path.resolve(path.dirname(outFile));
-                }
             }
         }
         else {
@@ -527,7 +523,7 @@ task("importDefinitelyTypedTests", [importDefinitelyTypedTestsJs], function () {
 
 // Local target to build the compiler and services
 var tscFile = path.join(builtLocalDirectory, compilerFilename);
-compileFile(tscFile, compilerSources, [builtLocalDirectory, copyright].concat(compilerSources), [copyright], /*useBuiltCompiler:*/ false, { noMapRoot: true });
+compileFile(tscFile, compilerSources, [builtLocalDirectory, copyright].concat(compilerSources), [copyright], /*useBuiltCompiler:*/ false);
 
 var servicesFile = path.join(builtLocalDirectory, "typescriptServices.js");
 var servicesFileInBrowserTest = path.join(builtLocalDirectory, "typescriptServicesInBrowserTest.js");
@@ -582,7 +578,6 @@ compileFile(
         keepComments: true,
         noResolve: false,
         stripInternal: true,
-        noMapRoot: true,
         inlineSourceMap: true
     });
 
diff --git a/scripts/tslint/nextLineRule.ts b/scripts/tslint/nextLineRule.ts
index b149d09eb38..fa03746afc6 100644
--- a/scripts/tslint/nextLineRule.ts
+++ b/scripts/tslint/nextLineRule.ts
@@ -18,7 +18,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
 function walk(ctx: Lint.WalkContext<void>, checkCatch: boolean, checkElse: boolean): void {
     const { sourceFile } = ctx;
-    function recur(node: ts.Node): void {
+    ts.forEachChild(sourceFile, function recur(node) {
         switch (node.kind) {
             case ts.SyntaxKind.IfStatement:
                 checkIf(node as ts.IfStatement);
@@ -28,7 +28,7 @@ function walk(ctx: Lint.WalkContext<void>, checkCatch: boolean, checkElse: boole
                 break;
         }
         ts.forEachChild(node, recur);
-    }
+    });
 
     function checkIf(node: ts.IfStatement): void {
         const { thenStatement, elseStatement } = node;
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index d55f3650c10..22209e2e41e 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -2333,7 +2333,7 @@ namespace ts {
             // A common practice in node modules is to set 'export = module.exports = {}', this ensures that 'exports'
             // is still pointing to 'module.exports'.
             // We do not want to consider this as 'export=' since a module can have only one of these.
-            // Similarlly we do not want to treat 'module.exports = exports' as an 'export='.
+            // Similarly we do not want to treat 'module.exports = exports' as an 'export='.
             const assignedExpression = getRightMostAssignedExpression(node.right);
             if (isEmptyObjectLiteral(assignedExpression) || isExportsOrModuleExportsOrAlias(assignedExpression)) {
                 // Mark it as a module in case there are no other exports in the file
@@ -2741,6 +2741,10 @@ namespace ts {
             transformFlags |= TransformFlags.AssertES2015;
         }
 
+        if (expression.kind === SyntaxKind.ImportKeyword) {
+            transformFlags |= TransformFlags.ContainsDynamicImport;
+        }
+
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
         return transformFlags & ~TransformFlags.ArrayLiteralOrCallOrNewExcludes;
     }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a3f8b9facad..6188f1aead9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -210,6 +210,11 @@ namespace ts {
             getSuggestionForNonexistentProperty,
             getSuggestionForNonexistentSymbol,
             getBaseConstraintOfType,
+            getJsxNamespace,
+            resolveNameAtLocation(location: Node, name: string, meaning: SymbolFlags): Symbol | undefined {
+                location = getParseTreeNode(location);
+                return resolveName(location, name, meaning, /*nameNotFoundMessage*/ undefined, name);
+            },
         };
 
         const tupleTypes: GenericType[] = [];
@@ -735,6 +740,7 @@ namespace ts {
             if (declarationFile !== useFile) {
                 if ((modulekind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
                     (!compilerOptions.outFile && !compilerOptions.out) ||
+                    isInTypeQuery(usage) ||
                     isInAmbientContext(declaration)) {
                     // nodes are in different files and order cannot be determined
                     return true;
@@ -847,7 +853,7 @@ namespace ts {
             location: Node | undefined,
             name: string,
             meaning: SymbolFlags,
-            nameNotFoundMessage: DiagnosticMessage,
+            nameNotFoundMessage: DiagnosticMessage | undefined,
             nameArg: string | Identifier,
             suggestedNameNotFoundMessage?: DiagnosticMessage): Symbol {
             return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, getSymbol, suggestedNameNotFoundMessage);
@@ -1364,6 +1370,9 @@ namespace ts {
         // An 'import { Point } from "graphics"' needs to create a symbol that combines the value side 'Point'
         // property with the type/namespace side interface 'Point'.
         function combineValueAndTypeSymbols(valueSymbol: Symbol, typeSymbol: Symbol): Symbol {
+            if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) {
+                return unknownSymbol;
+            }
             if (valueSymbol.flags & (SymbolFlags.Type | SymbolFlags.Namespace)) {
                 return valueSymbol;
             }
@@ -2282,10 +2291,10 @@ namespace ts {
 
         function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
             const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName);
-            Debug.assert(typeNode !== undefined, "should always get typenode?");
+            Debug.assert(typeNode !== undefined, "should always get typenode");
             const options = { removeComments: true };
             const writer = createTextWriter("");
-            const printer = createPrinter(options, writer);
+            const printer = createPrinter(options);
             const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
             printer.writeNode(EmitHint.Unspecified, typeNode, /*sourceFile*/ sourceFile, writer);
             const result = writer.getText();
@@ -5841,7 +5850,8 @@ namespace ts {
                     }
                 }
                 return arrayFrom(props.values());
-            } else {
+            }
+            else {
                 return getPropertiesOfType(type);
             }
         }
@@ -8356,6 +8366,12 @@ namespace ts {
         /**
          * This is *not* a bi-directional relationship.
          * If one needs to check both directions for comparability, use a second call to this function or 'checkTypeComparableTo'.
+         *
+         * A type S is comparable to a type T if some (but not necessarily all) of the possible values of S are also possible values of T.
+         * It is used to check following cases:
+         *   - the types of the left and right sides of equality/inequality operators (`===`, `!==`, `==`, `!=`).
+         *   - the types of `case` clause expressions and their respective `switch` expressions.
+         *   - the type of an expression in a type assertion with the type being asserted.
          */
         function isTypeComparableTo(source: Type, target: Type): boolean {
             return isTypeRelatedTo(source, target, comparableRelation);
@@ -8583,6 +8599,7 @@ namespace ts {
 
         function isEmptyObjectType(type: Type): boolean {
             return type.flags & TypeFlags.Object ? isEmptyResolvedType(resolveStructuredTypeMembers(<ObjectType>type)) :
+                type.flags & TypeFlags.NonPrimitive ? true :
                 type.flags & TypeFlags.Union ? forEach((<UnionType>type).types, isEmptyObjectType) :
                 type.flags & TypeFlags.Intersection ? !forEach((<UnionType>type).types, t => !isEmptyObjectType(t)) :
                 false;
@@ -8702,6 +8719,7 @@ namespace ts {
             let expandingFlags: number;
             let depth = 0;
             let overflow = false;
+            let isIntersectionConstituent = false;
 
             Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
 
@@ -8784,7 +8802,6 @@ namespace ts {
              * * Ternary.False if they are not related.
              */
             function isRelatedTo(source: Type, target: Type, reportErrors?: boolean, headMessage?: DiagnosticMessage): Ternary {
-                let result: Ternary;
                 if (source.flags & TypeFlags.StringOrNumberLiteral && source.flags & TypeFlags.FreshLiteral) {
                     source = (<LiteralType>source).regularType;
                 }
@@ -8816,32 +8833,40 @@ namespace ts {
                     }
                 }
 
+                if (relation !== comparableRelation &&
+                    !(source.flags & TypeFlags.UnionOrIntersection) &&
+                    !(target.flags & TypeFlags.Union) &&
+                    !isIntersectionConstituent &&
+                    source !== globalObjectType &&
+                    getPropertiesOfType(source).length > 0 &&
+                    isWeakType(target) &&
+                    !hasCommonProperties(source, target)) {
+                    if (reportErrors) {
+                        reportError(Diagnostics.Type_0_has_no_properties_in_common_with_type_1, typeToString(source), typeToString(target));
+                    }
+                    return Ternary.False;
+                }
+
+                let result = Ternary.False;
                 const saveErrorInfo = errorInfo;
+                const saveIsIntersectionConstituent = isIntersectionConstituent;
+                isIntersectionConstituent = false;
 
                 // Note that these checks are specifically ordered to produce correct results. In particular,
                 // we need to deconstruct unions before intersections (because unions are always at the top),
                 // and we need to handle "each" relations before "some" relations for the same kind of type.
                 if (source.flags & TypeFlags.Union) {
-                    if (relation === comparableRelation) {
-                        result = someTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive));
-                    }
-                    else {
-                        result = eachTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive));
-                    }
-                    if (result) {
-                        return result;
-                    }
+                    result = relation === comparableRelation ?
+                        someTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive)) :
+                        eachTypeRelatedToType(source as UnionType, target, reportErrors && !(source.flags & TypeFlags.Primitive));
                 }
                 else {
                     if (target.flags & TypeFlags.Union) {
-                        if (result = typeRelatedToSomeType(source, <UnionType>target, reportErrors && !(source.flags & TypeFlags.Primitive) && !(target.flags & TypeFlags.Primitive))) {
-                            return result;
-                        }
+                        result = typeRelatedToSomeType(source, <UnionType>target, reportErrors && !(source.flags & TypeFlags.Primitive) && !(target.flags & TypeFlags.Primitive));
                     }
                     else if (target.flags & TypeFlags.Intersection) {
-                        if (result = typeRelatedToEachType(source, target as IntersectionType, reportErrors)) {
-                            return result;
-                        }
+                        isIntersectionConstituent = true;
+                        result = typeRelatedToEachType(source, target as IntersectionType, reportErrors);
                     }
                     else if (source.flags & TypeFlags.Intersection) {
                         // Check to see if any constituents of the intersection are immediately related to the target.
@@ -8857,20 +8882,18 @@ namespace ts {
                         //
                         //    - For a primitive type or type parameter (such as 'number = A & B') there is no point in
                         //          breaking the intersection apart.
-                        if (result = someTypeRelatedToType(<IntersectionType>source, target, /*reportErrors*/ false)) {
-                            return result;
-                        }
+                        result = someTypeRelatedToType(<IntersectionType>source, target, /*reportErrors*/ false);
                     }
-
-                    if (source.flags & TypeFlags.StructuredOrTypeVariable || target.flags & TypeFlags.StructuredOrTypeVariable) {
+                    if (!result && (source.flags & TypeFlags.StructuredOrTypeVariable || target.flags & TypeFlags.StructuredOrTypeVariable)) {
                         if (result = recursiveTypeRelatedTo(source, target, reportErrors)) {
                             errorInfo = saveErrorInfo;
-                            return result;
                         }
                     }
                 }
 
-                if (reportErrors) {
+                isIntersectionConstituent = saveIsIntersectionConstituent;
+
+                if (!result && reportErrors) {
                     if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Primitive) {
                         tryElaborateErrorsForPrimitivesAndObjects(source, target);
                     }
@@ -8879,7 +8902,7 @@ namespace ts {
                     }
                     reportRelationError(headMessage, source, target);
                 }
-                return Ternary.False;
+                return result;
             }
 
             function isIdenticalTo(source: Type, target: Type): Ternary {
@@ -8978,7 +9001,7 @@ namespace ts {
                 }
             }
 
-            function typeRelatedToEachType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary {
+            function typeRelatedToEachType(source: Type, target: IntersectionType, reportErrors: boolean): Ternary {
                 let result = Ternary.True;
                 const targetTypes = target.types;
                 for (const targetType of targetTypes) {
@@ -9280,7 +9303,6 @@ namespace ts {
                 const requireOptionalProperties = relation === subtypeRelation && !(getObjectFlags(source) & ObjectFlags.ObjectLiteral);
                 for (const targetProp of properties) {
                     const sourceProp = getPropertyOfType(source, targetProp.name);
-
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
                             if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) {
@@ -9359,6 +9381,34 @@ namespace ts {
                 return result;
             }
 
+            /**
+             * A type is 'weak' if it is an object type with at least one optional property
+             * and no required properties, call/construct signatures or index signatures
+             */
+            function isWeakType(type: Type): boolean {
+                if (type.flags & TypeFlags.Object) {
+                    const resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                    return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 &&
+                        !resolved.stringIndexInfo && !resolved.numberIndexInfo &&
+                        resolved.properties.length > 0 &&
+                        every(resolved.properties, p => !!(p.flags & SymbolFlags.Optional));
+                }
+                if (type.flags & TypeFlags.Intersection) {
+                    return every((<IntersectionType>type).types, isWeakType);
+                }
+                return false;
+            }
+
+            function hasCommonProperties(source: Type, target: Type) {
+                const isComparingJsxAttributes = !!(source.flags & TypeFlags.JsxAttributes);
+                for (const prop of getPropertiesOfType(source)) {
+                    if (isKnownProperty(target, prop.name, isComparingJsxAttributes)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             function propertiesIdenticalTo(source: Type, target: Type): Ternary {
                 if (!(source.flags & TypeFlags.Object && target.flags & TypeFlags.Object)) {
                     return Ternary.False;
@@ -14118,7 +14168,7 @@ namespace ts {
             checkJsxPreconditions(node);
             // The reactNamespace/jsxFactory's root symbol should be marked as 'used' so we don't incorrectly elide its import.
             // And if there is no reactNamespace/jsxFactory's symbol in scope when targeting React emit, we should issue an error.
-            const reactRefErr = compilerOptions.jsx === JsxEmit.React ? Diagnostics.Cannot_find_name_0 : undefined;
+            const reactRefErr = diagnostics && compilerOptions.jsx === JsxEmit.React ? Diagnostics.Cannot_find_name_0 : undefined;
             const reactNamespace = getJsxNamespace();
             const reactSym = resolveName(node.tagName, reactNamespace, SymbolFlags.Value, reactRefErr, reactNamespace);
             if (reactSym) {
@@ -14147,8 +14197,10 @@ namespace ts {
         function isKnownProperty(targetType: Type, name: string, isComparingJsxAttributes: boolean): boolean {
             if (targetType.flags & TypeFlags.Object) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>targetType);
-                if (resolved.stringIndexInfo || resolved.numberIndexInfo && isNumericLiteralName(name) ||
-                    getPropertyOfType(targetType, name) || isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
+                if (resolved.stringIndexInfo ||
+                    resolved.numberIndexInfo && isNumericLiteralName(name) ||
+                    getPropertyOfType(targetType, name) ||
+                    isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
                     // For JSXAttributes, if the attribute has a hyphenated name, consider that the attribute to be known.
                     return true;
                 }
@@ -14487,6 +14539,7 @@ namespace ts {
             const maximumLengthDifference = Math.min(3, name.length * 0.34);
             let bestDistance = Number.MAX_VALUE;
             let bestCandidate = undefined;
+            let justCheckExactMatches = false;
             if (name.length > 30) {
                 return undefined;
             }
@@ -14499,6 +14552,9 @@ namespace ts {
                     if (candidateName === name) {
                         return candidate;
                     }
+                    if (justCheckExactMatches) {
+                        continue;
+                    }
                     if (candidateName.length < 3 ||
                         name.length < 3 ||
                         candidateName === "eval" ||
@@ -14514,7 +14570,8 @@ namespace ts {
                         continue;
                     }
                     if (distance < 3) {
-                        return candidate;
+                        justCheckExactMatches = true;
+                        bestCandidate = candidate;
                     }
                     else if (distance < bestDistance) {
                         bestDistance = distance;
@@ -16123,6 +16180,35 @@ namespace ts {
             return getReturnTypeOfSignature(signature);
         }
 
+        function checkImportCallExpression(node: ImportCall): Type {
+            // Check grammar of dynamic import
+            checkGrammarArguments(node, node.arguments) || checkGrammarImportCallExpression(node);
+
+            if (node.arguments.length === 0) {
+                return createPromiseReturnType(node, anyType);
+            }
+            const specifier = node.arguments[0];
+            const specifierType = checkExpressionCached(specifier);
+            // Even though multiple arugments is grammatically incorrect, type-check extra arguments for completion
+            for (let i = 1; i < node.arguments.length; ++i) {
+                checkExpressionCached(node.arguments[i]);
+            }
+
+            if (specifierType.flags & TypeFlags.Undefined || specifierType.flags & TypeFlags.Null || !isTypeAssignableTo(specifierType, stringType)) {
+                error(specifier, Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
+            }
+
+            // resolveExternalModuleName will return undefined if the moduleReferenceExpression is not a string literal
+            const moduleSymbol = resolveExternalModuleName(node, specifier);
+            if (moduleSymbol) {
+                const esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true);
+                if (esModuleSymbol) {
+                    return createPromiseReturnType(node, getTypeOfSymbol(esModuleSymbol));
+                }
+            }
+            return createPromiseReturnType(node, anyType);
+        }
+
         function isCommonJsRequire(node: Node) {
             if (!isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
                 return false;
@@ -16329,14 +16415,18 @@ namespace ts {
             return emptyObjectType;
         }
 
-        function createPromiseReturnType(func: FunctionLikeDeclaration, promisedType: Type) {
+        function createPromiseReturnType(func: FunctionLikeDeclaration | ImportCall, promisedType: Type) {
             const promiseType = createPromiseType(promisedType);
             if (promiseType === emptyObjectType) {
-                error(func, Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
+                error(func, isImportCall(func) ?
+                    Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option :
+                    Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
                 return unknownType;
             }
             else if (!getGlobalPromiseConstructorSymbol(/*reportErrors*/ true)) {
-                error(func, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+                error(func, isImportCall(func) ?
+                    Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option :
+                    Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
             }
 
             return promiseType;
@@ -17695,6 +17785,10 @@ namespace ts {
                 case SyntaxKind.ElementAccessExpression:
                     return checkIndexedAccess(<ElementAccessExpression>node);
                 case SyntaxKind.CallExpression:
+                    if ((<CallExpression>node).expression.kind === SyntaxKind.ImportKeyword) {
+                        return checkImportCallExpression(<ImportCall>node);
+                    }
+                    /* falls through */
                 case SyntaxKind.NewExpression:
                     return checkCallExpression(<CallExpression>node);
                 case SyntaxKind.TaggedTemplateExpression:
@@ -22704,12 +22798,12 @@ namespace ts {
                 return symbols;
             }
             else if (symbol.flags & SymbolFlags.Transient) {
-                if ((symbol as SymbolLinks).leftSpread) {
-                    const links = symbol as SymbolLinks;
-                    return [...getRootSymbols(links.leftSpread), ...getRootSymbols(links.rightSpread)];
+                const transient = symbol as TransientSymbol;
+                if (transient.leftSpread) {
+                    return [...getRootSymbols(transient.leftSpread), ...getRootSymbols(transient.rightSpread)];
                 }
-                if ((symbol as SymbolLinks).syntheticOrigin) {
-                    return getRootSymbols((symbol as SymbolLinks).syntheticOrigin);
+                if (transient.syntheticOrigin) {
+                    return getRootSymbols(transient.syntheticOrigin);
                 }
 
                 let target: Symbol;
@@ -24620,6 +24714,27 @@ namespace ts {
             });
             return result;
         }
+
+        function checkGrammarImportCallExpression(node: ImportCall): boolean {
+            if (modulekind === ModuleKind.ES2015) {
+                return grammarErrorOnNode(node, Diagnostics.Dynamic_import_cannot_be_used_when_targeting_ECMAScript_2015_modules);
+            }
+
+            if (node.typeArguments) {
+                return grammarErrorOnNode(node, Diagnostics.Dynamic_import_cannot_have_type_arguments);
+            }
+
+            const arguments = node.arguments;
+            if (arguments.length !== 1) {
+                return grammarErrorOnNode(node, Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument);
+            }
+
+            // see: parseArgumentOrArrayLiteralElement...we use this function which parse arguments of callExpression to parse specifier for dynamic import.
+            // parseArgumentOrArrayLiteralElement allows spread element to be in an argument list which is not allowed as specifier in dynamic import.
+            if (isSpreadElement(arguments[0])) {
+                return grammarErrorOnNode(arguments[0], Diagnostics.Specifier_of_dynamic_import_cannot_be_spread_element);
+            }
+        }
     }
 
     /** Like 'isDeclarationName', but returns true for LHS of `import { x as y }` or `export { x as y }`. */
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index e612378671d..23efd047e46 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -100,11 +100,12 @@ namespace ts {
                 "umd": ModuleKind.UMD,
                 "es6": ModuleKind.ES2015,
                 "es2015": ModuleKind.ES2015,
+                "esnext": ModuleKind.ESNext
             }),
             paramType: Diagnostics.KIND,
             showInSimplifiedHelpView: true,
             category: Diagnostics.Basic_Options,
-            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
+            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_es2015_or_ESNext,
         },
         {
             name: "lib",
@@ -1042,7 +1043,7 @@ namespace ts {
             for (let i = 0; i < nameColumn.length; i++) {
                 const optionName = nameColumn[i];
                 const description = descriptionColumn[i];
-                result.push(tab + tab + optionName + makePadding(marginLength - optionName.length + 2) + description);
+                result.push(optionName && `${tab}${tab}${optionName}${ description && (makePadding(marginLength - optionName.length + 2) + description)}`);
             }
             if (configurations.files && configurations.files.length) {
                 result.push(`${tab}},`);
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 5819e634ff4..1792a393234 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -473,7 +473,7 @@ namespace ts {
      * @param array The array to map.
      * @param mapfn The callback used to map the result into one or more values.
      */
-    export function flatMap<T, U>(array: T[], mapfn: (x: T, i: number) => U | U[]): U[] {
+    export function flatMap<T, U>(array: T[] | undefined, mapfn: (x: T, i: number) => U | U[] | undefined): U[] | undefined {
         let result: U[];
         if (array) {
             result = [];
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index a7b6db70e5e..70efe50143e 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -883,6 +883,23 @@
         "category": "Error",
         "code": 1322
     },
+    "Dynamic import cannot be used when targeting ECMAScript 2015 modules.": {
+        "category": "Error",
+        "code": 1323
+    },
+    "Dynamic import must have one specifier as an argument.": {
+        "category": "Error",
+        "code": 1324
+    },
+    "Specifier of dynamic import cannot be spread element.": {
+        "category": "Error",
+        "code": 1325
+    },
+    "Dynamic import cannot have type arguments": {
+        "category": "Error",
+        "code": 1326
+    },
+
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1879,6 +1896,10 @@
         "category": "Error",
         "code": 2558
     },
+    "Type '{0}' has no properties in common with type '{1}'.": {
+        "category": "Error",
+        "code": 2559
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600
@@ -1923,10 +1944,6 @@
         "category": "Error",
         "code": 2649
     },
-    "Cannot emit namespaced JSX elements in React.": {
-        "category": "Error",
-        "code": 2650
-    },
     "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums.": {
         "category": "Error",
         "code": 2651
@@ -2159,6 +2176,14 @@
         "category": "Error",
         "code": 2710
     },
+    "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option.": {
+        "category": "Error",
+        "code": 2711
+    },
+    "A dynamic import call in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.": {
+        "category": "Error",
+        "code": 2712
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -2625,7 +2650,7 @@
         "category": "Message",
         "code": 6015
     },
-    "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'.": {
+    "Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'.": {
         "category": "Message",
         "code": 6016
     },
@@ -3361,6 +3386,11 @@
         "category": "Error",
         "code": 7035
     },
+    "Dynamic import's specifier must be of type 'string', but here has type '{0}'.": {
+        "category": "Error",
+        "code": 7036
+    },
+
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
@@ -3555,11 +3585,11 @@
         "category": "Message",
         "code": 90015
     },
-    "Add declaration for missing property '{0}'.": {
+    "Declare property '{0}'.": {
         "category": "Message",
         "code": 90016
     },
-    "Add index signature for missing property '{0}'.": {
+    "Add index signature for property '{0}'.": {
         "category": "Message",
         "code": 90017
     },
@@ -3583,7 +3613,15 @@
         "category": "Message",
         "code": 90022
     },
-
+    "Declare method '{0}'.": {
+        "category": "Message",
+        "code": 90023
+    },
+    "Declare static method '{0}'.": {
+        "category": "Message",
+        "code": 90024
+    },
+    
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 1d2f75fcd60..1e6cc3b12db 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -676,6 +676,7 @@ namespace ts {
                 case SyntaxKind.SuperKeyword:
                 case SyntaxKind.TrueKeyword:
                 case SyntaxKind.ThisKeyword:
+                case SyntaxKind.ImportKeyword:
                     writeTokenNode(node);
                     return;
 
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 26c40b05239..12e8110e7be 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -2503,6 +2503,7 @@ namespace ts {
             helpers
         } = sourceEmitNode;
         if (!destEmitNode) destEmitNode = {};
+        // We are using `.slice()` here in case `destEmitNode.leadingComments` is pushed to later.
         if (leadingComments) destEmitNode.leadingComments = addRange(leadingComments.slice(), destEmitNode.leadingComments);
         if (trailingComments) destEmitNode.trailingComments = addRange(trailingComments.slice(), destEmitNode.trailingComments);
         if (flags) destEmitNode.flags = flags;
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 849f97bbbaf..84306cd81d8 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -46,10 +46,16 @@ namespace ts {
         }
     }
 
-    // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
-    // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
-    // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
-    // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
+    /**
+     * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
+     * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
+     * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
+     * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
+     *
+     * @param node a given node to visit its children
+     * @param cbNode a callback to be invoked for all child nodes
+     * @param cbNodeArray a callback to be invoked for embedded array
+     */
     export function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
         if (!node) {
             return;
@@ -2409,7 +2415,7 @@ namespace ts {
             if (token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.LessThanToken) {
                 return parseSignatureMember(SyntaxKind.CallSignature);
             }
-            if (token() === SyntaxKind.NewKeyword && lookAhead(isStartOfConstructSignature)) {
+            if (token() === SyntaxKind.NewKeyword && lookAhead(nextTokenIsOpenParenOrLessThan)) {
                 return parseSignatureMember(SyntaxKind.ConstructSignature);
             }
             const fullStart = getNodePos();
@@ -2420,7 +2426,7 @@ namespace ts {
             return parsePropertyOrMethodSignature(fullStart, modifiers);
         }
 
-        function isStartOfConstructSignature() {
+        function nextTokenIsOpenParenOrLessThan() {
             nextToken();
             return token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.LessThanToken;
         }
@@ -2777,6 +2783,8 @@ namespace ts {
                 case SyntaxKind.SlashEqualsToken:
                 case SyntaxKind.Identifier:
                     return true;
+                case SyntaxKind.ImportKeyword:
+                    return lookAhead(nextTokenIsOpenParenOrLessThan);
                 default:
                     return isIdentifier();
             }
@@ -3509,10 +3517,10 @@ namespace ts {
              *      5) --UnaryExpression[?Yield]
              */
             if (isUpdateExpression()) {
-                const incrementExpression = parseIncrementExpression();
+                const updateExpression = parseUpdateExpression();
                 return token() === SyntaxKind.AsteriskAsteriskToken ?
-                    <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
-                    incrementExpression;
+                    <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), updateExpression) :
+                    updateExpression;
             }
 
             /**
@@ -3578,7 +3586,7 @@ namespace ts {
                     }
                     // falls through
                 default:
-                    return parseIncrementExpression();
+                    return parseUpdateExpression();
             }
         }
 
@@ -3594,7 +3602,7 @@ namespace ts {
          */
         function isUpdateExpression(): boolean {
             // This function is called inside parseUnaryExpression to decide
-            // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
+            // whether to call parseSimpleUnaryExpression or call parseUpdateExpression directly
             switch (token()) {
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.MinusToken:
@@ -3618,9 +3626,9 @@ namespace ts {
         }
 
         /**
-         * Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
+         * Parse ES7 UpdateExpression. UpdateExpression is used instead of ES6's PostFixExpression.
          *
-         * ES7 IncrementExpression[yield]:
+         * ES7 UpdateExpression[yield]:
          *      1) LeftHandSideExpression[?yield]
          *      2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
          *      3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
@@ -3628,7 +3636,7 @@ namespace ts {
          *      5) --LeftHandSideExpression[?yield]
          * In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
          */
-        function parseIncrementExpression(): IncrementExpression {
+        function parseUpdateExpression(): UpdateExpression {
             if (token() === SyntaxKind.PlusPlusToken || token() === SyntaxKind.MinusMinusToken) {
                 const node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
                 node.operator = <PrefixUnaryOperator>token();
@@ -3678,17 +3686,27 @@ namespace ts {
             //      CallExpression Arguments
             //      CallExpression[Expression]
             //      CallExpression.IdentifierName
-            //      super   (   ArgumentListopt   )
+            //      import (AssignmentExpression)
+            //      super Arguments
             //      super.IdentifierName
             //
-            // Because of the recursion in these calls, we need to bottom out first.  There are two
-            // bottom out states we can run into.  Either we see 'super' which must start either of
-            // the last two CallExpression productions.  Or we have a MemberExpression which either
-            // completes the LeftHandSideExpression, or starts the beginning of the first four
-            // CallExpression productions.
-            const expression = token() === SyntaxKind.SuperKeyword
-                ? parseSuperExpression()
-                : parseMemberExpressionOrHigher();
+            // Because of the recursion in these calls, we need to bottom out first. There are three
+            // bottom out states we can run into: 1) We see 'super' which must start either of
+            // the last two CallExpression productions. 2) We see 'import' which must start import call.
+            // 3)we have a MemberExpression which either completes the LeftHandSideExpression,
+            // or starts the beginning of the first four CallExpression productions.
+            let expression: MemberExpression;
+            if (token() === SyntaxKind.ImportKeyword) {
+                // We don't want to eagerly consume all import keyword as import call expression so we look a head to find "("
+                // For example:
+                //      var foo3 = require("subfolder
+                //      import * as foo1 from "module-from-node  -> we want this import to be a statement rather than import call expression
+                sourceFile.flags |= NodeFlags.PossiblyContainDynamicImport;
+                expression = parseTokenNode<PrimaryExpression>();
+            }
+            else {
+                expression = token() === SyntaxKind.SuperKeyword ? parseSuperExpression() : parseMemberExpressionOrHigher();
+            }
 
             // Now, we *may* be complete.  However, we might have consumed the start of a
             // CallExpression.  As such, we need to consume the rest of it here to be complete.
@@ -3696,7 +3714,7 @@ namespace ts {
         }
 
         function parseMemberExpressionOrHigher(): MemberExpression {
-            // Note: to make our lives simpler, we decompose the the NewExpression productions and
+            // Note: to make our lives simpler, we decompose the NewExpression productions and
             // place ObjectCreationExpression and FunctionExpression into PrimaryExpression.
             // like so:
             //
@@ -4792,9 +4810,11 @@ namespace ts {
                 case SyntaxKind.FinallyKeyword:
                     return true;
 
+                case SyntaxKind.ImportKeyword:
+                    return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThan);
+
                 case SyntaxKind.ConstKeyword:
                 case SyntaxKind.ExportKeyword:
-                case SyntaxKind.ImportKeyword:
                     return isStartOfDeclaration();
 
                 case SyntaxKind.AsyncKeyword:
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index e69a89cc618..92c50e6ddff 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -984,16 +984,12 @@ namespace ts {
             if (sourceFile) {
                 return getDiagnostics(sourceFile, cancellationToken);
             }
-
-            const allDiagnostics: Diagnostic[] = [];
-            forEach(program.getSourceFiles(), sourceFile => {
+            return sortAndDeduplicateDiagnostics(flatMap(program.getSourceFiles(), sourceFile => {
                 if (cancellationToken) {
                     cancellationToken.throwIfCancellationRequested();
                 }
-                addRange(allDiagnostics, getDiagnostics(sourceFile, cancellationToken));
-            });
-
-            return sortAndDeduplicateDiagnostics(allDiagnostics);
+                return getDiagnostics(sourceFile, cancellationToken);
+            }));
         }
 
         function getSyntacticDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {
@@ -1069,10 +1065,10 @@ namespace ts {
                 const typeChecker = getDiagnosticsProducingTypeChecker();
 
                 Debug.assert(!!sourceFile.bindDiagnostics);
-                const bindDiagnostics = sourceFile.bindDiagnostics;
                 // For JavaScript files, we don't want to report semantic errors unless explicitly requested.
-                const includeCheckDiagnostics = !isSourceFileJavaScript(sourceFile) || isCheckJsEnabledForFile(sourceFile, options);
-                const checkDiagnostics = includeCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : [];
+                const includeBindAndCheckDiagnostics = !isSourceFileJavaScript(sourceFile) || isCheckJsEnabledForFile(sourceFile, options);
+                const bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
+                const checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
                 const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);
                 const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
 
@@ -1330,16 +1326,13 @@ namespace ts {
         }
 
         function getOptionsDiagnostics(): Diagnostic[] {
-            const allDiagnostics: Diagnostic[] = [];
-            addRange(allDiagnostics, fileProcessingDiagnostics.getGlobalDiagnostics());
-            addRange(allDiagnostics, programDiagnostics.getGlobalDiagnostics());
-            return sortAndDeduplicateDiagnostics(allDiagnostics);
+            return sortAndDeduplicateDiagnostics(concatenate(
+                fileProcessingDiagnostics.getGlobalDiagnostics(),
+                programDiagnostics.getGlobalDiagnostics()));
         }
 
         function getGlobalDiagnostics(): Diagnostic[] {
-            const allDiagnostics: Diagnostic[] = [];
-            addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics());
-            return sortAndDeduplicateDiagnostics(allDiagnostics);
+            return sortAndDeduplicateDiagnostics(getDiagnosticsProducingTypeChecker().getGlobalDiagnostics().slice());
         }
 
         function processRootFile(fileName: string, isDefaultLib: boolean) {
@@ -1366,6 +1359,7 @@ namespace ts {
             const isJavaScriptFile = isSourceFileJavaScript(file);
             const isExternalModuleFile = isExternalModule(file);
 
+            // file.imports may not be undefined if there exists dynamic import
             let imports: LiteralExpression[];
             let moduleAugmentations: LiteralExpression[];
             let ambientModules: string[];
@@ -1385,8 +1379,8 @@ namespace ts {
 
             for (const node of file.statements) {
                 collectModuleReferences(node, /*inAmbientModule*/ false);
-                if (isJavaScriptFile) {
-                    collectRequireCalls(node);
+                if ((file.flags & NodeFlags.PossiblyContainDynamicImport) || isJavaScriptFile) {
+                    collectDynamicImportOrRequireCalls(node);
                 }
             }
 
@@ -1449,12 +1443,16 @@ namespace ts {
                 }
             }
 
-            function collectRequireCalls(node: Node): void {
+            function collectDynamicImportOrRequireCalls(node: Node): void {
                 if (isRequireCall(node, /*checkArgumentIsStringLiteral*/ true)) {
                     (imports || (imports = [])).push(<StringLiteral>(<CallExpression>node).arguments[0]);
                 }
+                // we have to check the argument list has length of 1. We will still have to process these even though we have parsing error.
+                else if (isImportCall(node) && node.arguments.length === 1 && node.arguments[0].kind === SyntaxKind.StringLiteral) {
+                    (imports || (imports = [])).push(<StringLiteral>(<CallExpression>node).arguments[0]);
+                }
                 else {
-                    forEachChild(node, collectRequireCalls);
+                    forEachChild(node, collectDynamicImportOrRequireCalls);
                 }
             }
         }
@@ -1486,7 +1484,8 @@ namespace ts {
                     }
                 }
                 return sourceFile;
-            } else {
+            }
+            else {
                 const sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile(fileName);
                 if (sourceFileNoExtension) return sourceFileNoExtension;
 
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 0a072a3b8ac..68a36c40a80 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -286,7 +286,7 @@ namespace ts {
 
     const tokenStrings = makeReverseMap(textToToken);
 
-    export function tokenToString(t: SyntaxKind): string {
+    export function tokenToString(t: SyntaxKind): string | undefined {
         return tokenStrings[t];
     }
 
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index 75f9c43c6fe..f0c827d8396 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -15,6 +15,7 @@
 namespace ts {
     function getModuleTransformer(moduleKind: ModuleKind): TransformerFactory<SourceFile> {
         switch (moduleKind) {
+            case ModuleKind.ESNext:
             case ModuleKind.ES2015:
                 return transformES2015Module;
             case ModuleKind.System:
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index a0656476421..7acbd3126b4 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -2095,9 +2095,9 @@ namespace ts {
                     enableSubstitutionsForBlockScopedBindings();
                 }
 
-                const declarations = flatten(map(node.declarations, node.flags & NodeFlags.Let
+                const declarations = flatMap(node.declarations, node.flags & NodeFlags.Let
                     ? visitVariableDeclarationInLetDeclarationList
-                    : visitVariableDeclaration));
+                    : visitVariableDeclaration);
 
                 const declarationList = createVariableDeclarationList(declarations);
                 setOriginalNode(declarationList, node);
diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index 6e2f70b5c35..a3aa0139aa4 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -351,8 +351,10 @@ namespace ts {
             );
         }
 
-        function awaitAsYield(expression: Expression) {
-            return createYield(/*asteriskToken*/ undefined, enclosingFunctionFlags & FunctionFlags.Generator ? createAwaitHelper(context, expression) : expression);
+        function createDownlevelAwait(expression: Expression) {
+            return enclosingFunctionFlags & FunctionFlags.Generator
+                ? createYield(/*asteriskToken*/ undefined, createAwaitHelper(context, expression))
+                : createAwait(expression);
         }
 
         function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement) {
@@ -385,11 +387,11 @@ namespace ts {
                             EmitFlags.NoHoisting
                         ),
                         /*condition*/ createComma(
-                            createAssignment(result, awaitAsYield(callNext)),
+                            createAssignment(result, createDownlevelAwait(callNext)),
                             createLogicalNot(getDone)
                         ),
                         /*incrementor*/ undefined,
-                        /*statement*/ convertForOfStatementHead(node, awaitAsYield(getValue))
+                        /*statement*/ convertForOfStatementHead(node, createDownlevelAwait(getValue))
                     ),
                     /*location*/ node
                 ),
@@ -434,7 +436,7 @@ namespace ts {
                                             createPropertyAccess(iterator, "return")
                                         )
                                     ),
-                                    createStatement(awaitAsYield(callReturn))
+                                    createStatement(createDownlevelAwait(callReturn))
                                 ),
                                 EmitFlags.SingleLine
                             )
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index b3e544a3f8b..b2e1c1c70a9 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -46,6 +46,7 @@ namespace ts {
         let currentSourceFile: SourceFile; // The current file.
         let currentModuleInfo: ExternalModuleInfo; // The ExternalModuleInfo for the current file.
         let noSubstitution: boolean[]; // Set of nodes for which substitution rules should be ignored.
+        let needUMDDynamicImportHelper: boolean;
 
         return transformSourceFile;
 
@@ -55,7 +56,7 @@ namespace ts {
          * @param node The SourceFile node.
          */
         function transformSourceFile(node: SourceFile) {
-            if (node.isDeclarationFile || !(isExternalModule(node) || compilerOptions.isolatedModules)) {
+            if (node.isDeclarationFile || !(isExternalModule(node) || compilerOptions.isolatedModules || node.transformFlags & TransformFlags.ContainsDynamicImport)) {
                 return node;
             }
 
@@ -66,9 +67,9 @@ namespace ts {
             // Perform the transformation.
             const transformModule = getTransformModuleDelegate(moduleKind);
             const updated = transformModule(node);
-
             currentSourceFile = undefined;
             currentModuleInfo = undefined;
+            needUMDDynamicImportHelper = false;
             return aggregateTransformFlags(updated);
         }
 
@@ -107,6 +108,7 @@ namespace ts {
                 // we need to inform the emitter to add the __export helper.
                 addEmitHelper(updated, exportStarHelper);
             }
+            addEmitHelpers(updated, context.readEmitHelpers());
             return updated;
         }
 
@@ -411,6 +413,9 @@ namespace ts {
                 // we need to inform the emitter to add the __export helper.
                 addEmitHelper(body, exportStarHelper);
             }
+            if (needUMDDynamicImportHelper) {
+                addEmitHelper(body, dynamicImportUMDHelper);
+            }
 
             return body;
         }
@@ -488,12 +493,110 @@ namespace ts {
                     return visitEndOfDeclarationMarker(<EndOfDeclarationMarker>node);
 
                 default:
-                    // This visitor does not descend into the tree, as export/import statements
-                    // are only transformed at the top level of a file.
-                    return node;
+                    return visitEachChild(node, importCallExpressionVisitor, context);
             }
         }
 
+        function importCallExpressionVisitor(node: Node): VisitResult<Node> {
+            // This visitor does not need to descend into the tree if there is no dynamic import,
+            // as export/import statements are only transformed at the top level of a file.
+            if (!(node.transformFlags & TransformFlags.ContainsDynamicImport)) {
+                return node;
+            }
+
+            if (isImportCall(node)) {
+                return visitImportCallExpression(<ImportCall>node);
+            }
+            else {
+                return visitEachChild(node, importCallExpressionVisitor, context);
+            }
+        }
+
+        function visitImportCallExpression(node: ImportCall): Expression {
+            switch (compilerOptions.module) {
+                case ModuleKind.CommonJS:
+                    return transformImportCallExpressionCommonJS(node);
+                case ModuleKind.AMD:
+                    return transformImportCallExpressionAMD(node);
+                case ModuleKind.UMD:
+                    return transformImportCallExpressionUMD(node);
+            }
+            Debug.fail("All supported module kind in this transformation step should have been handled");
+        }
+
+        function transformImportCallExpressionUMD(node: ImportCall): Expression {
+            // (function (factory) {
+            //      ... (regular UMD)
+            // }
+            // })(function (require, exports, useSyncRequire) {
+            //      "use strict";
+            //      Object.defineProperty(exports, "__esModule", { value: true });
+            //      var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+            //      var __resolved = new Promise(function (resolve) { resolve(); });
+            //      .....
+            //      __syncRequire
+            //          ? __resolved.then(function () { return require(x); }) /*CommonJs Require*/
+            //          : new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/
+            // });
+            needUMDDynamicImportHelper = true;
+            return createConditional(
+                /*condition*/ createIdentifier("__syncRequire"),
+                /*whenTrue*/ transformImportCallExpressionCommonJS(node),
+                /*whenFalse*/ transformImportCallExpressionAMD(node)
+            );
+        }
+
+        function transformImportCallExpressionAMD(node: ImportCall): Expression {
+            // improt("./blah")
+            // emit as
+            // define(["require", "exports", "blah"], function (require, exports) {
+            //     ...
+            //     new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/
+            // });
+            const resolve = createUniqueName("resolve");
+            const reject = createUniqueName("reject");
+            return createNew(
+                createIdentifier("Promise"),
+                /*typeArguments*/ undefined,
+                [createFunctionExpression(
+                    /*modifiers*/ undefined,
+                    /*asteriskToken*/ undefined,
+                    /*name*/ undefined,
+                    /*typeParameters*/ undefined,
+                    [createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),
+                     createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)],
+                    /*type*/ undefined,
+                    createBlock([createStatement(
+                        createCall(
+                            createIdentifier("require"),
+                            /*typeArguments*/ undefined,
+                            [createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject]
+                        ))])
+            )]);
+        }
+
+    function transformImportCallExpressionCommonJS(node: ImportCall): Expression {
+            // import("./blah")
+            // emit as
+            // Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/
+            // We have to wrap require in then callback so that require is done in asynchronously
+            // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately
+            return createCall(
+                createPropertyAccess(
+                    createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []),
+                    "then"),
+                /*typeArguments*/ undefined,
+                [createFunctionExpression(
+                    /*modifiers*/ undefined,
+                    /*asteriskToken*/ undefined,
+                    /*name*/ undefined,
+                    /*typeParameters*/ undefined,
+                    /*parameters*/ undefined,
+                    /*type*/ undefined,
+                    createBlock([createReturn(createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments))])
+                )]);
+        }
+
         /**
          * Visits an ImportDeclaration node.
          *
@@ -786,9 +889,9 @@ namespace ts {
                                 node.asteriskToken,
                                 getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
                                 /*typeParameters*/ undefined,
-                                node.parameters,
+                                visitNodes(node.parameters, importCallExpressionVisitor),
                                 /*type*/ undefined,
-                                node.body
+                                visitEachChild(node.body, importCallExpressionVisitor, context)
                             ),
                             /*location*/ node
                         ),
@@ -797,7 +900,7 @@ namespace ts {
                 );
             }
             else {
-                statements = append(statements, node);
+                statements = append(statements, visitEachChild(node, importCallExpressionVisitor, context));
             }
 
             if (hasAssociatedEndOfDeclarationMarker(node)) {
@@ -828,7 +931,7 @@ namespace ts {
                                 visitNodes(node.modifiers, modifierVisitor, isModifier),
                                 getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
                                 /*typeParameters*/ undefined,
-                                node.heritageClauses,
+                                visitNodes(node.heritageClauses, importCallExpressionVisitor),
                                 node.members
                             ),
                             node
@@ -838,7 +941,7 @@ namespace ts {
                 );
             }
             else {
-                statements = append(statements, node);
+                statements = append(statements, visitEachChild(node, importCallExpressionVisitor, context));
             }
 
             if (hasAssociatedEndOfDeclarationMarker(node)) {
@@ -890,7 +993,7 @@ namespace ts {
                 }
             }
             else {
-                statements = append(statements, node);
+                statements = append(statements, visitEachChild(node, importCallExpressionVisitor, context));
             }
 
             if (hasAssociatedEndOfDeclarationMarker(node)) {
@@ -913,7 +1016,7 @@ namespace ts {
         function transformInitializedVariable(node: VariableDeclaration): Expression {
             if (isBindingPattern(node.name)) {
                 return flattenDestructuringAssignment(
-                    node,
+                    visitNode(node, importCallExpressionVisitor),
                     /*visitor*/ undefined,
                     context,
                     FlattenLevel.All,
@@ -930,7 +1033,7 @@ namespace ts {
                         ),
                         /*location*/ node.name
                     ),
-                    node.initializer
+                    visitNode(node.initializer, importCallExpressionVisitor)
                 );
             }
         }
@@ -1497,4 +1600,12 @@ namespace ts {
                 for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
             }`
     };
+
+    // emit helper for dynamic import
+    const dynamicImportUMDHelper: EmitHelper = {
+        name: "typescript:dynamicimport-sync-require",
+        scoped: true,
+        text: `
+            var __syncRequire = typeof module === "object" && typeof module.exports === "object";`
+    };
 }
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index e6351c0965e..fa126d1faa7 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -50,7 +50,7 @@ namespace ts {
          * @param node The SourceFile node.
          */
         function transformSourceFile(node: SourceFile) {
-            if (node.isDeclarationFile || !(isExternalModule(node) || compilerOptions.isolatedModules)) {
+            if (node.isDeclarationFile || !(isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & TransformFlags.ContainsDynamicImport)) {
                 return node;
             }
 
@@ -646,7 +646,7 @@ namespace ts {
                 return undefined;
             }
 
-            const expression = visitNode(node.expression, destructuringVisitor, isExpression);
+            const expression = visitNode(node.expression, destructuringAndImportCallVisitor, isExpression);
             const original = node.original;
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
@@ -673,12 +673,12 @@ namespace ts {
                         node.asteriskToken,
                         getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
                         /*typeParameters*/ undefined,
-                        visitNodes(node.parameters, destructuringVisitor, isParameterDeclaration),
+                        visitNodes(node.parameters, destructuringAndImportCallVisitor, isParameterDeclaration),
                         /*type*/ undefined,
-                        visitNode(node.body, destructuringVisitor, isBlock)));
+                        visitNode(node.body, destructuringAndImportCallVisitor, isBlock)));
             }
             else {
-                hoistedStatements = append(hoistedStatements, node);
+                hoistedStatements = append(hoistedStatements, visitEachChild(node, destructuringAndImportCallVisitor, context));
             }
 
             if (hasAssociatedEndOfDeclarationMarker(node)) {
@@ -716,8 +716,8 @@ namespace ts {
                                     /*modifiers*/ undefined,
                                     node.name,
                                     /*typeParameters*/ undefined,
-                                    visitNodes(node.heritageClauses, destructuringVisitor, isHeritageClause),
-                                    visitNodes(node.members, destructuringVisitor, isClassElement)
+                                    visitNodes(node.heritageClauses, destructuringAndImportCallVisitor, isHeritageClause),
+                                    visitNodes(node.members, destructuringAndImportCallVisitor, isClassElement)
                                 ),
                                 node
                             )
@@ -747,7 +747,7 @@ namespace ts {
          */
         function visitVariableStatement(node: VariableStatement): VisitResult<Statement> {
             if (!shouldHoistVariableDeclarationList(node.declarationList)) {
-                return visitNode(node, destructuringVisitor, isStatement);
+                return visitNode(node, destructuringAndImportCallVisitor, isStatement);
             }
 
             let expressions: Expression[];
@@ -820,13 +820,13 @@ namespace ts {
             return isBindingPattern(node.name)
                 ? flattenDestructuringAssignment(
                     node,
-                    destructuringVisitor,
+                    destructuringAndImportCallVisitor,
                     context,
                     FlattenLevel.All,
                     /*needsValue*/ false,
                     createAssignment
                 )
-                : createAssignment(node.name, visitNode(node.initializer, destructuringVisitor, isExpression));
+                : createAssignment(node.name, visitNode(node.initializer, destructuringAndImportCallVisitor, isExpression));
         }
 
         /**
@@ -1204,7 +1204,7 @@ namespace ts {
                     return visitEndOfDeclarationMarker(<EndOfDeclarationMarker>node);
 
                 default:
-                    return destructuringVisitor(node);
+                    return destructuringAndImportCallVisitor(node);
             }
         }
 
@@ -1220,8 +1220,8 @@ namespace ts {
             node = updateFor(
                 node,
                 visitForInitializer(node.initializer),
-                visitNode(node.condition, destructuringVisitor, isExpression),
-                visitNode(node.incrementor, destructuringVisitor, isExpression),
+                visitNode(node.condition, destructuringAndImportCallVisitor, isExpression),
+                visitNode(node.incrementor, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.statement, nestedElementVisitor, isStatement)
             );
 
@@ -1241,7 +1241,7 @@ namespace ts {
             node = updateForIn(
                 node,
                 visitForInitializer(node.initializer),
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.statement, nestedElementVisitor, isStatement, liftToBlock)
             );
 
@@ -1262,7 +1262,7 @@ namespace ts {
                 node,
                 node.awaitModifier,
                 visitForInitializer(node.initializer),
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.statement, nestedElementVisitor, isStatement, liftToBlock)
             );
 
@@ -1313,7 +1313,7 @@ namespace ts {
             return updateDo(
                 node,
                 visitNode(node.statement, nestedElementVisitor, isStatement, liftToBlock),
-                visitNode(node.expression, destructuringVisitor, isExpression)
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression)
             );
         }
 
@@ -1325,7 +1325,7 @@ namespace ts {
         function visitWhileStatement(node: WhileStatement): VisitResult<Statement> {
             return updateWhile(
                 node,
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.statement, nestedElementVisitor, isStatement, liftToBlock)
             );
         }
@@ -1351,7 +1351,7 @@ namespace ts {
         function visitWithStatement(node: WithStatement): VisitResult<Statement> {
             return updateWith(
                 node,
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.statement, nestedElementVisitor, isStatement, liftToBlock)
             );
         }
@@ -1364,7 +1364,7 @@ namespace ts {
         function visitSwitchStatement(node: SwitchStatement): VisitResult<Statement> {
             return updateSwitch(
                 node,
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNode(node.caseBlock, nestedElementVisitor, isCaseBlock)
             );
         }
@@ -1395,7 +1395,7 @@ namespace ts {
         function visitCaseClause(node: CaseClause): VisitResult<CaseOrDefaultClause> {
             return updateCaseClause(
                 node,
-                visitNode(node.expression, destructuringVisitor, isExpression),
+                visitNode(node.expression, destructuringAndImportCallVisitor, isExpression),
                 visitNodes(node.statements, nestedElementVisitor, isStatement)
             );
         }
@@ -1461,19 +1461,43 @@ namespace ts {
          *
          * @param node The node to visit.
          */
-        function destructuringVisitor(node: Node): VisitResult<Node> {
+        function destructuringAndImportCallVisitor(node: Node): VisitResult<Node> {
             if (node.transformFlags & TransformFlags.DestructuringAssignment
                 && node.kind === SyntaxKind.BinaryExpression) {
                 return visitDestructuringAssignment(<DestructuringAssignment>node);
             }
-            else if (node.transformFlags & TransformFlags.ContainsDestructuringAssignment) {
-                return visitEachChild(node, destructuringVisitor, context);
+            else if (isImportCall(node)) {
+                return visitImportCallExpression(node);
+            }
+            else if ((node.transformFlags & TransformFlags.ContainsDestructuringAssignment) || (node.transformFlags & TransformFlags.ContainsDynamicImport)) {
+                return visitEachChild(node, destructuringAndImportCallVisitor, context);
             }
             else {
                 return node;
             }
         }
 
+        function visitImportCallExpression(node: ImportCall): Expression {
+            // import("./blah")
+            // emit as
+            // System.register([], function (_export, _context) {
+            //     return {
+            //         setters: [],
+            //         execute: () => {
+            //             _context.import('./blah');
+            //         }
+            //     };
+            // });
+            return createCall(
+                createPropertyAccess(
+                    contextObject,
+                    createIdentifier("import")
+                ),
+                /*typeArguments*/ undefined,
+                node.arguments
+            );
+        }
+
         /**
          * Visits a DestructuringAssignment to flatten destructuring to exported symbols.
          *
@@ -1483,14 +1507,14 @@ namespace ts {
             if (hasExportedReferenceInDestructuringTarget(node.left)) {
                 return flattenDestructuringAssignment(
                     node,
-                    destructuringVisitor,
+                    destructuringAndImportCallVisitor,
                     context,
                     FlattenLevel.All,
                     /*needsValue*/ true
                 );
             }
 
-            return visitEachChild(node, destructuringVisitor, context);
+            return visitEachChild(node, destructuringAndImportCallVisitor, context);
         }
 
         /**
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index ed1d5dcbe23..1c7f36bb27b 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -395,6 +395,7 @@ namespace ts {
 
         // Enum value count
         Count,
+
         // Markers
         FirstAssignment = EqualsToken,
         LastAssignment = CaretEqualsToken,
@@ -449,6 +450,14 @@ namespace ts {
         ThisNodeOrAnySubNodesHasError = 1 << 17, // If this node or any of its children had an error
         HasAggregatedChildData = 1 << 18, // If we've computed data from children and cached it in this node
 
+        // This flag will be set to true when the parse encounter dynamic import so that post-parsing process of module resolution
+        // will not walk the tree if the flag is not set. However, this flag is just a approximation because once it is set, the flag never get reset.
+        // (hence it is named "possiblyContainDynamicImport").
+        // During editing, if dynamic import is remove, incremental parsing will *NOT* update this flag. This will then causes walking of the tree during module resolution.
+        // However, the removal operation should not occur often and in the case of the removal, it is likely that users will add back the import anyway.
+        // The advantage of this approach is its simplicity. For the case of batch compilation, we garuntee that users won't have to pay the price of walking the tree if dynamic import isn't used.
+        PossiblyContainDynamicImport = 1 << 19,
+
         BlockScoped = Let | Const,
 
         ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,
@@ -1001,8 +1010,10 @@ namespace ts {
         _unaryExpressionBrand: any;
     }
 
-    export interface IncrementExpression extends UnaryExpression {
-        _incrementExpressionBrand: any;
+    /** Deprecated, please use UpdateExpression */
+    export type IncrementExpression = UpdateExpression;
+    export interface UpdateExpression extends UnaryExpression {
+        _updateExpressionBrand: any;
     }
 
     // see: https://tc39.github.io/ecma262/#prod-UpdateExpression
@@ -1013,10 +1024,9 @@ namespace ts {
         | SyntaxKind.PlusToken
         | SyntaxKind.MinusToken
         | SyntaxKind.TildeToken
-        | SyntaxKind.ExclamationToken
-        ;
+        | SyntaxKind.ExclamationToken;
 
-    export interface PrefixUnaryExpression extends IncrementExpression {
+    export interface PrefixUnaryExpression extends UpdateExpression {
         kind: SyntaxKind.PrefixUnaryExpression;
         operator: PrefixUnaryOperator;
         operand: UnaryExpression;
@@ -1028,13 +1038,13 @@ namespace ts {
         | SyntaxKind.MinusMinusToken
         ;
 
-    export interface PostfixUnaryExpression extends IncrementExpression {
+    export interface PostfixUnaryExpression extends UpdateExpression {
         kind: SyntaxKind.PostfixUnaryExpression;
         operand: LeftHandSideExpression;
         operator: PostfixUnaryOperator;
     }
 
-    export interface LeftHandSideExpression extends IncrementExpression {
+    export interface LeftHandSideExpression extends UpdateExpression {
         _leftHandSideExpressionBrand: any;
     }
 
@@ -1062,6 +1072,10 @@ namespace ts {
         kind: SyntaxKind.SuperKeyword;
     }
 
+    export interface ImportExpression extends PrimaryExpression {
+        kind: SyntaxKind.ImportKeyword;
+    }
+
     export interface DeleteExpression extends UnaryExpression {
         kind: SyntaxKind.DeleteExpression;
         expression: UnaryExpression;
@@ -1454,10 +1468,7 @@ namespace ts {
     }
 
     // see: https://tc39.github.io/ecma262/#prod-SuperProperty
-    export type SuperProperty
-        = SuperPropertyAccessExpression
-        | SuperElementAccessExpression
-        ;
+    export type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;
 
     export interface CallExpression extends LeftHandSideExpression, Declaration {
         kind: SyntaxKind.CallExpression;
@@ -1471,6 +1482,10 @@ namespace ts {
         expression: SuperExpression;
     }
 
+    export interface ImportCall extends CallExpression {
+        expression: ImportExpression;
+    }
+
     export interface ExpressionWithTypeArguments extends TypeNode {
         kind: SyntaxKind.ExpressionWithTypeArguments;
         parent?: HeritageClause;
@@ -2535,7 +2550,6 @@ namespace ts {
         getNonNullableType(type: Type): Type;
 
         /** Note that the resulting nodes cannot be checked. */
-
         typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode;
         /** Note that the resulting nodes cannot be checked. */
         signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): SignatureDeclaration;
@@ -2605,6 +2619,9 @@ namespace ts {
          * Does not include properties of primitive types.
          */
         /* @internal */ getAllPossiblePropertiesOfType(type: Type): Symbol[];
+
+        /* @internal */ getJsxNamespace(): string;
+        /* @internal */ resolveNameAtLocation(location: Node, name: string, meaning: SymbolFlags): Symbol | undefined;
     }
 
     export enum NodeBuilderFlags {
@@ -3564,6 +3581,7 @@ namespace ts {
         UMD = 3,
         System = 4,
         ES2015 = 5,
+        ESNext = 6
     }
 
     export const enum JsxEmit {
@@ -3948,6 +3966,11 @@ namespace ts {
         ContainsYield = 1 << 24,
         ContainsHoistedDeclarationOrCompletion = 1 << 25,
 
+        ContainsDynamicImport = 1 << 26,
+
+        // Please leave this as 1 << 29.
+        // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
+        // It is a good reminder of how much room we have left
         HasComputedFlags = 1 << 29, // Transform flags have been computed.
 
         // Assertions
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b52ace78615..30f7e0a52f9 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -596,6 +596,10 @@ namespace ts {
         return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.SuperKeyword;
     }
 
+    export function isImportCall(n: Node): n is ImportCall {
+        return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.ImportKeyword;
+    }
+
     export function isPrologueDirective(node: Node): node is PrologueDirective {
         return node.kind === SyntaxKind.ExpressionStatement
             && (<ExpressionStatement>node).expression.kind === SyntaxKind.StringLiteral;
@@ -1434,24 +1438,10 @@ namespace ts {
     }
 
     function getJSDocTags(node: Node, kind: SyntaxKind): JSDocTag[] {
-        const docs = getJSDocs(node);
-        if (docs) {
-            const result: JSDocTag[] = [];
-            for (const doc of docs) {
-                if (doc.kind === SyntaxKind.JSDocParameterTag) {
-                    if (doc.kind === kind) {
-                        result.push(doc as JSDocTag);
-                    }
-                }
-                else {
-                    const tags = (doc as JSDoc).tags;
-                    if (tags) {
-                        result.push(...filter(tags, tag => tag.kind === kind));
-                    }
-                }
-            }
-            return result;
-        }
+        return flatMap(getJSDocs(node), doc =>
+            doc.kind === SyntaxKind.JSDocComment
+                ? filter((doc as JSDoc).tags, tag => tag.kind === kind)
+                : doc.kind === kind && doc);
     }
 
     function getFirstJSDocTag(node: Node, kind: SyntaxKind): JSDocTag {
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 8f19b83c7ad..07aacf3c8a7 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -479,24 +479,11 @@ namespace FourSlash {
         }
 
         private getDiagnostics(fileName: string): ts.Diagnostic[] {
-            const syntacticErrors = this.languageService.getSyntacticDiagnostics(fileName);
-            const semanticErrors = this.languageService.getSemanticDiagnostics(fileName);
-
-            const diagnostics: ts.Diagnostic[] = [];
-            diagnostics.push.apply(diagnostics, syntacticErrors);
-            diagnostics.push.apply(diagnostics, semanticErrors);
-
-            return diagnostics;
+            return this.languageService.getSyntacticDiagnostics(fileName).concat(this.languageService.getSemanticDiagnostics(fileName));
         }
 
         private getAllDiagnostics(): ts.Diagnostic[] {
-            const diagnostics: ts.Diagnostic[] = [];
-
-            for (const fileName of this.languageServiceAdapterHost.getFilenames()) {
-                diagnostics.push.apply(this.getDiagnostics(fileName));
-            }
-
-            return diagnostics;
+            return ts.flatMap(this.languageServiceAdapterHost.getFilenames(), fileName => this.getDiagnostics(fileName));
         }
 
         public verifyErrorExistsAfterMarker(markerName: string, negative: boolean, after: boolean) {
@@ -2276,23 +2263,22 @@ namespace FourSlash {
         }
 
         /**
-         * Compares expected text to the text that would be in the sole range
-         * (ie: [|...|]) in the file after applying the codefix sole codefix
-         * in the source file.
-         *
-         * Because codefixes are only applied on the working file, it is unsafe
-         * to apply this more than once (consider a refactoring across files).
+         * Finds and applies a code action corresponding to the supplied parameters.
+         * If index is undefined, applies the unique code action available.
+         * @param errorCode The error code that generated the code action.
+         * @param index The nth (0-index-based) codeaction available generated by errorCode.
          */
-        public verifyRangeAfterCodeFix(expectedText: string, includeWhiteSpace?: boolean, errorCode?: number, index?: number) {
+        public getAndApplyCodeActions(errorCode?: number, index?: number) {
+            const fileName = this.activeFile.fileName;
+            this.applyCodeActions(this.getCodeFixActions(fileName, errorCode), index);
+        }
+
+        public verifyRangeIs(expectedText: string, includeWhiteSpace?: boolean) {
             const ranges = this.getRanges();
             if (ranges.length !== 1) {
                 this.raiseError("Exactly one range should be specified in the testfile.");
             }
 
-            const fileName = this.activeFile.fileName;
-
-            this.applyCodeAction(fileName, this.getCodeFixActions(fileName, errorCode), index);
-
             const actualText = this.rangeText(ranges[0]);
 
             const result = includeWhiteSpace
@@ -2304,6 +2290,16 @@ namespace FourSlash {
             }
         }
 
+        /**
+         * Compares expected text to the text that would be in the sole range
+         * (ie: [|...|]) in the file after applying the codefix sole codefix
+         * in the source file.
+         */
+        public verifyRangeAfterCodeFix(expectedText: string, includeWhiteSpace?: boolean, errorCode?: number, index?: number) {
+            this.getAndApplyCodeActions(errorCode, index);
+            this.verifyRangeIs(expectedText, includeWhiteSpace);
+        }
+
         /**
          * Applies fixes for the errors in fileName and compares the results to
          * expectedContents after all fixes have been applied.
@@ -2316,7 +2312,7 @@ namespace FourSlash {
         public verifyFileAfterCodeFix(expectedContents: string, fileName?: string) {
             fileName = fileName ? fileName : this.activeFile.fileName;
 
-            this.applyCodeAction(fileName, this.getCodeFixActions(fileName));
+            this.applyCodeActions(this.getCodeFixActions(fileName));
 
             const actualContents: string = this.getFileContent(fileName);
             if (this.removeWhitespace(actualContents) !== this.removeWhitespace(expectedContents)) {
@@ -2354,11 +2350,10 @@ namespace FourSlash {
             return actions;
         }
 
-        private applyCodeAction(fileName: string, actions: ts.CodeAction[], index?: number): void {
+        private applyCodeActions(actions: ts.CodeAction[], index?: number): void {
             if (index === undefined) {
                 if (!(actions && actions.length === 1)) {
-                    const actionText = (actions && actions.length) ? JSON.stringify(actions) : "none";
-                    this.raiseError(`Should find exactly one codefix, but found ${actionText}`);
+                    this.raiseError(`Should find exactly one codefix, but ${actions ? actions.length : "none"} found.`);
                 }
                 index = 0;
             }
@@ -2368,12 +2363,11 @@ namespace FourSlash {
                 }
             }
 
-            const fileChanges = ts.find(actions[index].changes, change => change.fileName === fileName);
-            if (!fileChanges) {
-                this.raiseError("The CodeFix found doesn't provide any changes in this file.");
-            }
+            const changes = actions[index].changes;
 
-            this.applyEdits(fileChanges.fileName, fileChanges.textChanges, /*isFormattingEdit*/ false);
+            for (const change of changes) {
+                this.applyEdits(change.fileName, change.textChanges, /*isFormattingEdit*/ false);
+            }
         }
 
         public verifyImportFixAtPosition(expectedTextArray: string[], errorCode?: number) {
@@ -2385,7 +2379,10 @@ namespace FourSlash {
             const codeFixes = this.getCodeFixActions(this.activeFile.fileName, errorCode);
 
             if (!codeFixes || codeFixes.length === 0) {
-                this.raiseError("No codefixes returned.");
+                if (expectedTextArray.length !== 0) {
+                    this.raiseError("No codefixes returned.");
+                }
+                return;
             }
 
             const actualTextArray: string[] = [];
@@ -2758,7 +2755,7 @@ namespace FourSlash {
 
             const codeActions = this.languageService.getRefactorCodeActions(this.activeFile.fileName, formattingOptions, markerPos, refactorNameToApply);
 
-            this.applyCodeAction(this.activeFile.fileName, codeActions);
+            this.applyCodeActions(codeActions);
             const actualContent = this.getFileContent(this.activeFile.fileName);
 
             if (this.normalizeNewlines(actualContent) !== this.normalizeNewlines(expectedContent)) {
@@ -3805,6 +3802,14 @@ namespace FourSlashInterface {
             this.state.verifyFileAfterApplyingRefactorAtMarker(markerName, expectedContent, refactorNameToApply, formattingOptions);
         }
 
+        public rangeIs(expectedText: string, includeWhiteSpace?: boolean): void {
+            this.state.verifyRangeIs(expectedText, includeWhiteSpace);
+        }
+
+        public getAndApplyCodeFix(errorCode?: number, index?: number): void {
+            this.state.getAndApplyCodeActions(errorCode, index);
+        }
+
         public importFixAtPosition(expectedTextArray: string[], errorCode?: number): void {
             this.state.verifyImportFixAtPosition(expectedTextArray, errorCode);
         }
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 49dbdbf2102..9bf4591112d 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -857,6 +857,7 @@ namespace Harness {
 
         export function getDefaultLibFileName(options: ts.CompilerOptions): string {
             switch (options.target) {
+                case ts.ScriptTarget.ESNext:
                 case ts.ScriptTarget.ES2017:
                     return "lib.es2017.d.ts";
                 case ts.ScriptTarget.ES2016:
diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
index eeb47f0cfa0..76f585b623a 100644
--- a/src/harness/loggedIO.ts
+++ b/src/harness/loggedIO.ts
@@ -232,14 +232,11 @@ namespace Playback {
                 // different entry).
                 // TODO (yuisu): We can certainly remove these once we recapture the RWC using new API
                 const normalizedPath = ts.normalizePath(path).toLowerCase();
-                const result: string[] = [];
-                 for (const directory of replayLog.directoriesRead) {
+                return ts.flatMap(replayLog.directoriesRead, directory => {
                     if (ts.normalizeSlashes(directory.path).toLowerCase() === normalizedPath) {
-                        result.push(...directory.result);
+                        return directory.result;
                     }
-                }
-
-                return result;
+                });
             });
 
         wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
diff --git a/src/harness/unittests/commandLineParsing.ts b/src/harness/unittests/commandLineParsing.ts
index 19ccc919d4c..01a208aa330 100644
--- a/src/harness/unittests/commandLineParsing.ts
+++ b/src/harness/unittests/commandLineParsing.ts
@@ -113,7 +113,7 @@ namespace ts {
                         start: undefined,
                         length: undefined,
                     }, {
-                            messageText: "Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.",
+                            messageText: "Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.",
                             category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                             code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
diff --git a/src/harness/unittests/convertCompilerOptionsFromJson.ts b/src/harness/unittests/convertCompilerOptionsFromJson.ts
index 3aa1a4c9b8e..798f8c6a76b 100644
--- a/src/harness/unittests/convertCompilerOptionsFromJson.ts
+++ b/src/harness/unittests/convertCompilerOptionsFromJson.ts
@@ -122,7 +122,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.",
+                        messageText: "Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
diff --git a/src/harness/unittests/telemetry.ts b/src/harness/unittests/telemetry.ts
index d3811edf251..f250c732c0b 100644
--- a/src/harness/unittests/telemetry.ts
+++ b/src/harness/unittests/telemetry.ts
@@ -252,7 +252,8 @@ namespace ts.projectSystem {
         }
 
         getEvent<T extends server.ProjectServiceEvent>(eventName: T["eventName"], mayBeMore = false): T["data"] {
-            if (mayBeMore) assert(this.events.length !== 0); else assert.equal(this.events.length, 1);
+            if (mayBeMore) { assert(this.events.length !== 0); }
+            else { assert.equal(this.events.length, 1); }
             const event = this.events.shift();
             assert.equal(event.eventName, eventName);
             return event.data;
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 6f898e7f4a6..7a19aa9167f 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -13,7 +13,8 @@ namespace ts.projectSystem {
             express: "express",
             jquery: "jquery",
             lodash: "lodash",
-            moment: "moment"
+            moment: "moment",
+            chroma: "chroma-js"
         })
     };
 
@@ -61,7 +62,6 @@ namespace ts.projectSystem {
             super(installTypingHost, globalTypingsCacheLocation, safeList.path, throttleLimit, log);
         }
 
-        safeFileList = safeList.path;
         protected postExecActions: PostExecAction[] = [];
 
         executePendingCommands() {
diff --git a/src/harness/unittests/typingsInstaller.ts b/src/harness/unittests/typingsInstaller.ts
index 699b1807428..c356d0941c0 100644
--- a/src/harness/unittests/typingsInstaller.ts
+++ b/src/harness/unittests/typingsInstaller.ts
@@ -1009,6 +1009,26 @@ namespace ts.projectSystem {
     });
 
     describe("discover typings", () => {
+        it("should use mappings from safe list", () => {
+            const app = {
+                path: "/a/b/app.js",
+                content: ""
+            };
+            const jquery = {
+                path: "/a/b/jquery.js",
+                content: ""
+            };
+            const chroma = {
+                path: "/a/b/chroma.min.js",
+                content: ""
+            };
+            const cache = createMap<string>();
+
+            const host = createServerHost([app, jquery, chroma]);
+            const result = JsTyping.discoverTypings(host, [app.path, jquery.path, chroma.path], getDirectoryPath(<Path>app.path), /*safeListPath*/ undefined, cache, { enable: true }, []);
+            assert.deepEqual(result.newTypingNames, ["jquery", "chroma-js"]);
+        });
+
         it("should return node for core modules", () => {
             const f = {
                 path: "/a/b/app.js",
@@ -1016,6 +1036,7 @@ namespace ts.projectSystem {
             };
             const host = createServerHost([f]);
             const cache = createMap<string>();
+
             for (const name of JsTyping.nodeCoreModuleList) {
                 const result = JsTyping.discoverTypings(host, [f.path], getDirectoryPath(<Path>f.path), /*safeListPath*/ undefined, cache, { enable: true }, [name, "somename"]);
                 assert.deepEqual(result.newTypingNames.sort(), ["node", "somename"]);
@@ -1040,7 +1061,7 @@ namespace ts.projectSystem {
     });
 
     describe("telemetry events", () => {
-        it ("should be received", () => {
+        it("should be received", () => {
             const f1 = {
                 path: "/a/app.js",
                 content: ""
@@ -1089,7 +1110,7 @@ namespace ts.projectSystem {
     });
 
     describe("progress notifications", () => {
-        it ("should be sent for success", () => {
+        it("should be sent for success", () => {
             const f1 = {
                 path: "/a/app.js",
                 content: ""
@@ -1140,7 +1161,7 @@ namespace ts.projectSystem {
             checkProjectActualFiles(projectService.inferredProjects[0], [f1.path, commander.path]);
         });
 
-        it ("should be sent for error", () => {
+        it("should be sent for error", () => {
             const f1 = {
                 path: "/a/app.js",
                 content: ""
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 3a85f4ddad9..6decc78558a 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -67,8 +67,8 @@ interface PropertyDescriptor {
     enumerable?: boolean;
     value?: any;
     writable?: boolean;
-    get? (): any;
-    set? (v: any): void;
+    get?(): any;
+    set?(v: any): void;
 }
 
 interface PropertyDescriptorMap {
@@ -108,7 +108,7 @@ interface Object {
 }
 
 interface ObjectConstructor {
-    new (value?: any): Object;
+    new(value?: any): Object;
     (): any;
     (value: any): any;
 
@@ -266,7 +266,7 @@ interface FunctionConstructor {
       * Creates a new function.
       * @param args A list of arguments the function accepts.
       */
-    new (...args: string[]): Function;
+    new(...args: string[]): Function;
     (...args: string[]): Function;
     readonly prototype: Function;
 }
@@ -403,7 +403,7 @@ interface String {
 }
 
 interface StringConstructor {
-    new (value?: any): String;
+    new(value?: any): String;
     (value?: any): string;
     readonly prototype: String;
     fromCharCode(...codes: number[]): string;
@@ -420,7 +420,7 @@ interface Boolean {
 }
 
 interface BooleanConstructor {
-    new (value?: any): Boolean;
+    new(value?: any): Boolean;
     (value?: any): boolean;
     readonly prototype: Boolean;
 }
@@ -457,7 +457,7 @@ interface Number {
 }
 
 interface NumberConstructor {
-    new (value?: any): Number;
+    new(value?: any): Number;
     (value?: any): number;
     readonly prototype: Number;
 
@@ -759,10 +759,10 @@ interface Date {
 }
 
 interface DateConstructor {
-    new (): Date;
-    new (value: number): Date;
-    new (value: string): Date;
-    new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
+    new(): Date;
+    new(value: number): Date;
+    new(value: string): Date;
+    new(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
     (): string;
     readonly prototype: Date;
     /**
@@ -828,8 +828,8 @@ interface RegExp {
 }
 
 interface RegExpConstructor {
-    new (pattern: RegExp | string): RegExp;
-    new (pattern: string, flags?: string): RegExp;
+    new(pattern: RegExp | string): RegExp;
+    new(pattern: string, flags?: string): RegExp;
     (pattern: RegExp | string): RegExp;
     (pattern: string, flags?: string): RegExp;
     readonly prototype: RegExp;
@@ -856,7 +856,7 @@ interface Error {
 }
 
 interface ErrorConstructor {
-    new (message?: string): Error;
+    new(message?: string): Error;
     (message?: string): Error;
     readonly prototype: Error;
 }
@@ -867,7 +867,7 @@ interface EvalError extends Error {
 }
 
 interface EvalErrorConstructor {
-    new (message?: string): EvalError;
+    new(message?: string): EvalError;
     (message?: string): EvalError;
     readonly prototype: EvalError;
 }
@@ -878,7 +878,7 @@ interface RangeError extends Error {
 }
 
 interface RangeErrorConstructor {
-    new (message?: string): RangeError;
+    new(message?: string): RangeError;
     (message?: string): RangeError;
     readonly prototype: RangeError;
 }
@@ -889,7 +889,7 @@ interface ReferenceError extends Error {
 }
 
 interface ReferenceErrorConstructor {
-    new (message?: string): ReferenceError;
+    new(message?: string): ReferenceError;
     (message?: string): ReferenceError;
     readonly prototype: ReferenceError;
 }
@@ -900,7 +900,7 @@ interface SyntaxError extends Error {
 }
 
 interface SyntaxErrorConstructor {
-    new (message?: string): SyntaxError;
+    new(message?: string): SyntaxError;
     (message?: string): SyntaxError;
     readonly prototype: SyntaxError;
 }
@@ -911,7 +911,7 @@ interface TypeError extends Error {
 }
 
 interface TypeErrorConstructor {
-    new (message?: string): TypeError;
+    new(message?: string): TypeError;
     (message?: string): TypeError;
     readonly prototype: TypeError;
 }
@@ -922,7 +922,7 @@ interface URIError extends Error {
 }
 
 interface URIErrorConstructor {
-    new (message?: string): URIError;
+    new(message?: string): URIError;
     (message?: string): URIError;
     readonly prototype: URIError;
 }
@@ -972,12 +972,10 @@ interface ReadonlyArray<T> {
       * Returns a string representation of an array.
       */
     toString(): string;
-    toLocaleString(): string;
     /**
-      * Combines two or more arrays.
-      * @param items Additional items to add to the end of array1.
+      * Returns a string representation of an array. The elements are converted to string using thier toLocalString methods.
       */
-    concat<U extends ReadonlyArray<T>>(...items: U[]): T[];
+    toLocaleString(): string;
     /**
       * Combines two or more arrays.
       * @param items Additional items to add to the end of array1.
@@ -1005,7 +1003,6 @@ interface ReadonlyArray<T> {
       * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
       */
     indexOf(searchElement: T, fromIndex?: number): number;
-
     /**
       * Returns the index of the last occurrence of a specified value in an array.
       * @param searchElement The value to locate in the array.
@@ -1017,49 +1014,37 @@ 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: 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;
+    every(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg?: any): 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: 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;
+    some(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => boolean, thisArg?: any): 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: 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;
+    forEach(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => void, thisArg?: any): 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: 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[];
+    map<U>(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => U, thisArg?: any): 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: 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[];
+    filter<S extends T>(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => value is S, thisArg?: any): 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: 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[];
+    filter(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => any, thisArg?: any): 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.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1097,6 +1082,9 @@ interface Array<T> {
       * Returns a string representation of an array.
       */
     toString(): string;
+    /**
+      * Returns a string representation of an array. The elements are converted to string using thier toLocalString methods.
+      */
     toLocaleString(): string;
     /**
       * Appends new elements to an array, and returns the new length of the array.
@@ -1176,73 +1164,37 @@ 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: 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;
+    every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): 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: 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;
+    some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): 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: 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;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): 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: 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];
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): 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: 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: 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: 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: 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<S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): 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: 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[];
+    filter(callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): 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.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1272,7 +1224,7 @@ interface Array<T> {
 }
 
 interface ArrayConstructor {
-    new (arrayLength?: number): any[];
+    new(arrayLength?: number): any[];
     new <T>(arrayLength: number): T[];
     new <T>(...items: T[]): T[];
     (arrayLength?: number): any[];
@@ -1396,7 +1348,7 @@ type ArrayBufferLike = ArrayBufferTypes[keyof ArrayBufferTypes];
 
 interface ArrayBufferConstructor {
     readonly prototype: ArrayBuffer;
-    new (byteLength: number): ArrayBuffer;
+    new(byteLength: number): ArrayBuffer;
     isView(arg: any): arg is ArrayBufferView;
 }
 declare const ArrayBuffer: ArrayBufferConstructor;
@@ -1547,7 +1499,7 @@ interface DataView {
 }
 
 interface DataViewConstructor {
-    new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number): DataView;
+    new(buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number): DataView;
 }
 declare const DataView: DataViewConstructor;
 
@@ -1595,9 +1547,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Int8Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -1616,9 +1566,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Int8Array) => any, thisArg?: any): Int8Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -1629,9 +1577,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -1642,9 +1588,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -1653,9 +1597,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Int8Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -1693,9 +1635,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number, thisArg: any): Int8Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1772,9 +1712,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Int8Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -1805,9 +1743,9 @@ interface Int8Array {
 }
 interface Int8ArrayConstructor {
     readonly prototype: Int8Array;
-    new (length: number): Int8Array;
-    new (array: ArrayLike<number>): Int8Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int8Array;
+    new(length: number): Int8Array;
+    new(array: ArrayLike<number>): Int8Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int8Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -1826,11 +1764,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;
 
-    from(arrayLike: ArrayLike<number>): Int8Array;
 
 }
 declare const Int8Array: Int8ArrayConstructor;
@@ -1879,9 +1814,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Uint8Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -1900,9 +1833,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Uint8Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -1913,9 +1844,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -1926,9 +1855,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -1937,9 +1864,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -1977,9 +1902,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number, thisArg: any): Uint8Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2056,9 +1979,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Uint8Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -2090,9 +2011,9 @@ interface Uint8Array {
 
 interface Uint8ArrayConstructor {
     readonly prototype: Uint8Array;
-    new (length: number): Uint8Array;
-    new (array: ArrayLike<number>): Uint8Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array;
+    new(length: number): Uint8Array;
+    new(array: ArrayLike<number>): Uint8Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -2111,11 +2032,7 @@ 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: 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;
+    from(arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;
 
 }
 declare const Uint8Array: Uint8ArrayConstructor;
@@ -2164,9 +2081,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -2185,9 +2100,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => any, thisArg?: any): Uint8ClampedArray;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -2198,9 +2111,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -2211,9 +2122,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2222,9 +2131,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -2262,9 +2169,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: any): Uint8ClampedArray;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2341,9 +2246,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -2375,9 +2278,9 @@ interface Uint8ClampedArray {
 
 interface Uint8ClampedArrayConstructor {
     readonly prototype: Uint8ClampedArray;
-    new (length: number): Uint8ClampedArray;
-    new (array: ArrayLike<number>): Uint8ClampedArray;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8ClampedArray;
+    new(length: number): Uint8ClampedArray;
+    new(array: ArrayLike<number>): Uint8ClampedArray;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8ClampedArray;
 
     /**
       * The size in bytes of each element in the array.
@@ -2396,11 +2299,7 @@ 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: 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;
+    from(arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;
 }
 declare const Uint8ClampedArray: Uint8ClampedArrayConstructor;
 
@@ -2448,9 +2347,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Int16Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -2469,9 +2366,7 @@ 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: 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;
+    filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -2482,9 +2377,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -2495,9 +2388,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2506,10 +2397,7 @@ 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: 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;
-
+    forEach(callbackfn: (value: number, index: number, array: Int16Array) => void, thisArg?: any): void;
     /**
       * Returns the index of the first occurrence of a value in an array.
       * @param searchElement The value to locate in the array.
@@ -2546,9 +2434,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number, thisArg: any): Int16Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2625,9 +2511,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Int16Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -2659,9 +2543,9 @@ interface Int16Array {
 
 interface Int16ArrayConstructor {
     readonly prototype: Int16Array;
-    new (length: number): Int16Array;
-    new (array: ArrayLike<number>): Int16Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int16Array;
+    new(length: number): Int16Array;
+    new(array: ArrayLike<number>): Int16Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int16Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -2680,11 +2564,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;
 
-    from(arrayLike: ArrayLike<number>): Int16Array;
 
 }
 declare const Int16Array: Int16ArrayConstructor;
@@ -2733,9 +2614,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Uint16Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -2754,9 +2633,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Uint16Array) => any, thisArg?: any): Uint16Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -2767,9 +2644,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -2780,9 +2655,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2791,9 +2664,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Uint16Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -2831,9 +2702,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number, thisArg: any): Uint16Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2910,9 +2779,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Uint16Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -2944,9 +2811,9 @@ interface Uint16Array {
 
 interface Uint16ArrayConstructor {
     readonly prototype: Uint16Array;
-    new (length: number): Uint16Array;
-    new (array: ArrayLike<number>): Uint16Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint16Array;
+    new(length: number): Uint16Array;
+    new(array: ArrayLike<number>): Uint16Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint16Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -2965,11 +2832,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;
 
-    from(arrayLike: ArrayLike<number>): Uint16Array;
 
 }
 declare const Uint16Array: Uint16ArrayConstructor;
@@ -3017,9 +2881,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Int32Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -3038,9 +2900,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Int32Array) => any, thisArg?: any): Int32Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -3051,9 +2911,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -3064,9 +2922,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3075,9 +2931,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Int32Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -3115,9 +2969,7 @@ 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: 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;
+    map(callbackfn: (value: number, index: number, array: Int32Array) => number, thisArg?: any): Int32Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3194,9 +3046,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Int32Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -3228,9 +3078,9 @@ interface Int32Array {
 
 interface Int32ArrayConstructor {
     readonly prototype: Int32Array;
-    new (length: number): Int32Array;
-    new (array: ArrayLike<number>): Int32Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int32Array;
+    new(length: number): Int32Array;
+    new(array: ArrayLike<number>): Int32Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int32Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -3249,11 +3099,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;
 
-    from(arrayLike: ArrayLike<number>): Int32Array;
 }
 declare const Int32Array: Int32ArrayConstructor;
 
@@ -3301,9 +3148,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Uint32Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -3322,9 +3167,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Uint32Array) => any, thisArg?: any): Uint32Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -3335,9 +3178,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -3348,9 +3189,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3359,10 +3198,7 @@ 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: 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;
-
+    forEach(callbackfn: (value: number, index: number, array: Uint32Array) => void, thisArg?: any): void;
     /**
       * Returns the index of the first occurrence of a value in an array.
       * @param searchElement The value to locate in the array.
@@ -3399,9 +3235,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number, thisArg: any): Uint32Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3478,9 +3312,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Uint32Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -3512,9 +3344,9 @@ interface Uint32Array {
 
 interface Uint32ArrayConstructor {
     readonly prototype: Uint32Array;
-    new (length: number): Uint32Array;
-    new (array: ArrayLike<number>): Uint32Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint32Array;
+    new(length: number): Uint32Array;
+    new(array: ArrayLike<number>): Uint32Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint32Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -3533,11 +3365,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;
 
-    from(arrayLike: ArrayLike<number>): Uint32Array;
 }
 declare const Uint32Array: Uint32ArrayConstructor;
 
@@ -3585,9 +3414,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -3606,9 +3433,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -3619,9 +3444,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -3632,9 +3455,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3643,9 +3464,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -3683,9 +3502,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number, thisArg: any): Float32Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3762,9 +3579,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -3796,9 +3611,9 @@ interface Float32Array {
 
 interface Float32ArrayConstructor {
     readonly prototype: Float32Array;
-    new (length: number): Float32Array;
-    new (array: ArrayLike<number>): Float32Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float32Array;
+    new(length: number): Float32Array;
+    new(array: ArrayLike<number>): Float32Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float32Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -3817,11 +3632,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;
 
-    from(arrayLike: ArrayLike<number>): Float32Array;
 
 }
 declare const Float32Array: Float32ArrayConstructor;
@@ -3870,9 +3682,7 @@ 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: 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;
+    every(callbackfn: (value: number, index: number, array: Float64Array) => boolean, thisArg?: any): boolean;
 
     /**
         * Returns the this object after filling the section identified by start and end with value
@@ -3891,9 +3701,7 @@ 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: 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;
+    filter(callbackfn: (value: number, index: number, array: Float64Array) => any, thisArg?: any): Float64Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -3904,9 +3712,7 @@ 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: 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;
+    find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
       * Returns the index of the first element in the array where predicate is true, and -1
@@ -3917,9 +3723,7 @@ 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: 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;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3928,9 +3732,7 @@ 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: 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;
+    forEach(callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any): void;
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -3968,9 +3770,7 @@ 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: 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;
+    map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -4047,9 +3847,7 @@ 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: 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;
+    some(callbackfn: (value: number, index: number, array: Float64Array) => boolean, thisArg?: any): boolean;
 
     /**
       * Sorts an array.
@@ -4081,9 +3879,9 @@ interface Float64Array {
 
 interface Float64ArrayConstructor {
     readonly prototype: Float64Array;
-    new (length: number): Float64Array;
-    new (array: ArrayLike<number>): Float64Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float64Array;
+    new(length: number): Float64Array;
+    new(array: ArrayLike<number>): Float64Array;
+    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float64Array;
 
     /**
       * The size in bytes of each element in the array.
@@ -4102,11 +3900,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: 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>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
 
-    from(arrayLike: ArrayLike<number>): Float64Array;
 }
 declare const Float64Array: Float64ArrayConstructor;
 
@@ -4139,7 +3934,7 @@ declare namespace Intl {
         resolvedOptions(): ResolvedCollatorOptions;
     }
     var Collator: {
-        new (locales?: string | string[], options?: CollatorOptions): Collator;
+        new(locales?: string | string[], options?: CollatorOptions): Collator;
         (locales?: string | string[], options?: CollatorOptions): Collator;
         supportedLocalesOf(locales: string | string[], options?: CollatorOptions): string[];
     };
@@ -4176,7 +3971,7 @@ declare namespace Intl {
         resolvedOptions(): ResolvedNumberFormatOptions;
     }
     var NumberFormat: {
-        new (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
+        new(locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
         (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
         supportedLocalesOf(locales: string | string[], options?: NumberFormatOptions): string[];
     };
@@ -4219,7 +4014,7 @@ declare namespace Intl {
         resolvedOptions(): ResolvedDateTimeFormatOptions;
     }
     var DateTimeFormat: {
-        new (locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
+        new(locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
         (locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
         supportedLocalesOf(locales: string | string[], options?: DateTimeFormatOptions): string[];
     };
diff --git a/src/server/project.ts b/src/server/project.ts
index 0646497acc5..be854f948ea 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -106,6 +106,7 @@ namespace ts.server {
         private rootFiles: ScriptInfo[] = [];
         private rootFilesMap: FileMap<ScriptInfo> = createFileMap<ScriptInfo>();
         private program: ts.Program;
+        private externalFiles: SortedReadonlyArray<string>;
 
         private cachedUnresolvedImportsPerFile = new UnresolvedImportsMap();
         private lastCachedUnresolvedImportsList: SortedReadonlyArray<string>;
@@ -261,8 +262,8 @@ namespace ts.server {
         abstract getProjectRootPath(): string | undefined;
         abstract getTypeAcquisition(): TypeAcquisition;
 
-        getExternalFiles(): string[] {
-            return [];
+        getExternalFiles(): SortedReadonlyArray<string> {
+            return emptyArray as SortedReadonlyArray<string>;
         }
 
         getSourceFile(path: Path) {
@@ -561,6 +562,24 @@ namespace ts.server {
                     }
                 }
             }
+
+            const oldExternalFiles = this.externalFiles || emptyArray as SortedReadonlyArray<string>;
+            this.externalFiles = this.getExternalFiles();
+            enumerateInsertsAndDeletes(this.externalFiles, oldExternalFiles,
+                // Ensure a ScriptInfo is created for new external files. This is performed indirectly
+                // by the LSHost for files in the program when the program is retrieved above but
+                // the program doesn't contain external files so this must be done explicitly.
+                inserted => {
+                    const scriptInfo = this.projectService.getOrCreateScriptInfo(inserted, /*openedByClient*/ false);
+                    scriptInfo.attachToProject(this);
+                },
+                removed => {
+                    const scriptInfoToDetach = this.projectService.getScriptInfo(removed);
+                    if (scriptInfoToDetach) {
+                        scriptInfoToDetach.detachFromProject(this);
+                    }
+                });
+
             return hasChanges;
         }
 
@@ -646,7 +665,7 @@ namespace ts.server {
 
                 const added: string[] = [];
                 const removed: string[] = [];
-                const updated: string[] = arrayFrom(updatedFileNames.keys());
+                const updated: string[] = updatedFileNames ? arrayFrom(updatedFileNames.keys()) : [];
 
                 forEachKey(currentFiles, id => {
                     if (!lastReportedFileNames.has(id)) {
@@ -956,19 +975,16 @@ namespace ts.server {
             return this.typeAcquisition;
         }
 
-        getExternalFiles(): string[] {
-            const items: string[] = [];
-            for (const plugin of this.plugins) {
-                if (typeof plugin.getExternalFiles === "function") {
-                    try {
-                        items.push(...plugin.getExternalFiles(this));
-                    }
-                    catch (e) {
-                        this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${e}`);
-                    }
+        getExternalFiles(): SortedReadonlyArray<string> {
+            return toSortedReadonlyArray(flatMap(this.plugins, plugin => {
+                if (typeof plugin.getExternalFiles !== "function") return;
+                try {
+                    return plugin.getExternalFiles(this);
                 }
-            }
-            return items;
+                catch (e) {
+                    this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${e}`);
+                }
+            }));
         }
 
         watchConfigFile(callback: (project: ConfiguredProject) => void) {
diff --git a/src/server/server.ts b/src/server/server.ts
index 390a0f2f6f4..7e1ee683c8c 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -45,6 +45,8 @@ namespace ts.server {
                     os.tmpdir();
                 return combinePaths(normalizeSlashes(basePath), "Microsoft/TypeScript");
             }
+            case "openbsd":
+            case "freebsd":
             case "darwin":
             case "linux":
             case "android": {
diff --git a/src/server/utilities.ts b/src/server/utilities.ts
index 093958b60c5..9e492601430 100644
--- a/src/server/utilities.ts
+++ b/src/server/utilities.ts
@@ -195,6 +195,37 @@ namespace ts.server {
         return <any>arr;
     }
 
+    export function enumerateInsertsAndDeletes<T>(a: SortedReadonlyArray<T>, b: SortedReadonlyArray<T>, inserted: (item: T) => void, deleted: (item: T) => void, compare?: (a: T, b: T) => Comparison) {
+        compare = compare || ts.compareValues;
+        let aIndex = 0;
+        let bIndex = 0;
+        const aLen = a.length;
+        const bLen = b.length;
+        while (aIndex < aLen && bIndex < bLen) {
+            const aItem = a[aIndex];
+            const bItem = b[bIndex];
+            const compareResult = compare(aItem, bItem);
+            if (compareResult === Comparison.LessThan) {
+                inserted(aItem);
+                aIndex++;
+            }
+            else if (compareResult === Comparison.GreaterThan) {
+                deleted(bItem);
+                bIndex++;
+            }
+            else {
+                aIndex++;
+                bIndex++;
+            }
+        }
+        while (aIndex < aLen) {
+            inserted(a[aIndex++]);
+        }
+        while (bIndex < bLen) {
+            deleted(b[bIndex++]);
+        }
+    }
+
     export class ThrottledOperations {
         private pendingTimeouts: Map<any> = createMap<any>();
         constructor(private readonly host: ServerHost) {
diff --git a/src/services/codefixes/fixAddMissingMember.ts b/src/services/codefixes/fixAddMissingMember.ts
index 64e7e560094..1587b47c01b 100644
--- a/src/services/codefixes/fixAddMissingMember.ts
+++ b/src/services/codefixes/fixAddMissingMember.ts
@@ -8,107 +8,161 @@ namespace ts.codefix {
 
     function getActionsForAddMissingMember(context: CodeFixContext): CodeAction[] | undefined {
 
-        const sourceFile = context.sourceFile;
+        const tokenSourceFile = context.sourceFile;
         const start = context.span.start;
-        // This is the identifier of the missing property. eg:
+        // The identifier of the missing property. eg:
         // this.missing = 1;
         //      ^^^^^^^
-        const token = getTokenAtPosition(sourceFile, start, /*includeJsDocComment*/ false);
+        const token = getTokenAtPosition(tokenSourceFile, start, /*includeJsDocComment*/ false);
 
         if (token.kind !== SyntaxKind.Identifier) {
             return undefined;
         }
 
-        if (!isPropertyAccessExpression(token.parent) || token.parent.expression.kind !== SyntaxKind.ThisKeyword) {
+        if (!isPropertyAccessExpression(token.parent)) {
             return undefined;
         }
 
-        const classMemberDeclaration = getThisContainer(token, /*includeArrowFunctions*/ false);
-        if (!isClassElement(classMemberDeclaration)) {
-            return undefined;
+        const tokenName = token.getText(tokenSourceFile);
+
+        let makeStatic = false;
+        let classDeclaration: ClassLikeDeclaration;
+
+        if (token.parent.expression.kind === SyntaxKind.ThisKeyword) {
+            const containingClassMemberDeclaration = getThisContainer(token, /*includeArrowFunctions*/ false);
+            if (!isClassElement(containingClassMemberDeclaration)) {
+                return undefined;
+            }
+
+            classDeclaration = <ClassLikeDeclaration>containingClassMemberDeclaration.parent;
+
+            // Property accesses on `this` in a static method are accesses of a static member.
+            makeStatic = classDeclaration && hasModifier(containingClassMemberDeclaration, ModifierFlags.Static);
+        }
+        else {
+
+            const checker = context.program.getTypeChecker();
+            const leftExpression = token.parent.expression;
+            const leftExpressionType = checker.getTypeAtLocation(leftExpression);
+
+            if (leftExpressionType.flags & TypeFlags.Object) {
+                const symbol = leftExpressionType.symbol;
+                if (symbol.flags & SymbolFlags.Class) {
+                    classDeclaration = symbol.declarations && <ClassLikeDeclaration>symbol.declarations[0];
+                    if (leftExpressionType !== checker.getDeclaredTypeOfSymbol(symbol)) {
+                        // The expression is a class symbol but the type is not the instance-side.
+                        makeStatic = true;
+                    }
+                }
+            }
         }
 
-        const classDeclaration = <ClassLikeDeclaration>classMemberDeclaration.parent;
         if (!classDeclaration || !isClassLike(classDeclaration)) {
             return undefined;
         }
 
-        const isStatic = hasModifier(classMemberDeclaration, ModifierFlags.Static);
+        const classDeclarationSourceFile = getSourceFileOfNode(classDeclaration);
+        const classOpenBrace = getOpenBraceOfClassLike(classDeclaration, classDeclarationSourceFile);
 
-        return isInJavaScriptFile(sourceFile) ? getActionsForAddMissingMemberInJavaScriptFile() : getActionsForAddMissingMemberInTypeScriptFile();
+        return isInJavaScriptFile(classDeclarationSourceFile) ?
+            getActionsForAddMissingMemberInJavaScriptFile(classDeclaration, makeStatic) :
+            getActionsForAddMissingMemberInTypeScriptFile(classDeclaration, makeStatic);
 
-        function getActionsForAddMissingMemberInJavaScriptFile(): CodeAction[] | undefined {
-            const memberName = token.getText();
+        function getActionsForAddMissingMemberInJavaScriptFile(classDeclaration: ClassLikeDeclaration, makeStatic: boolean): CodeAction[] | undefined {
+            let actions: CodeAction[];
 
-            if (isStatic) {
+            const methodCodeAction = getActionForMethodDeclaration(/*includeTypeScriptSyntax*/ false);
+            if (methodCodeAction) {
+                actions = [methodCodeAction];
+            }
+
+            if (makeStatic) {
                 if (classDeclaration.kind === SyntaxKind.ClassExpression) {
-                    return undefined;
+                    return actions;
                 }
 
                 const className = classDeclaration.name.getText();
 
-                return [{
-                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_static_property_0), [memberName]),
-                    changes: [{
-                        fileName: sourceFile.fileName,
-                        textChanges: [{
-                            span: { start: classDeclaration.getEnd(), length: 0 },
-                            newText: `${context.newLineCharacter}${className}.${memberName} = undefined;${context.newLineCharacter}`
-                        }]
-                    }]
-                }];
+                const staticInitialization = createStatement(createAssignment(
+                    createPropertyAccess(createIdentifier(className), tokenName),
+                    createIdentifier("undefined")));
 
+                const staticInitializationChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context);
+                staticInitializationChangeTracker.insertNodeAfter(
+                    classDeclarationSourceFile,
+                    classDeclaration,
+                    staticInitialization,
+                    { suffix: context.newLineCharacter });
+                const initializeStaticAction = {
+                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_static_property_0), [tokenName]),
+                    changes: staticInitializationChangeTracker.getChanges()
+                };
+
+                (actions || (actions = [])).push(initializeStaticAction);
+                return actions;
             }
             else {
                 const classConstructor = getFirstConstructorWithBody(classDeclaration);
                 if (!classConstructor) {
-                    return undefined;
+                    return actions;
                 }
 
-                return [{
-                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_property_0_in_the_constructor), [memberName]),
-                    changes: [{
-                        fileName: sourceFile.fileName,
-                        textChanges: [{
-                            span: { start: classConstructor.body.getEnd() - 1, length: 0 },
-                            newText: `this.${memberName} = undefined;${context.newLineCharacter}`
-                        }]
-                    }]
-                }];
+                const propertyInitialization = createStatement(createAssignment(
+                    createPropertyAccess(createThis(), tokenName),
+                    createIdentifier("undefined")));
+
+                const propertyInitializationChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context);
+                propertyInitializationChangeTracker.insertNodeAt(
+                    classDeclarationSourceFile,
+                    classConstructor.body.getEnd() - 1,
+                    propertyInitialization,
+                    { prefix: context.newLineCharacter, suffix: context.newLineCharacter });
+
+                const initializeAction = {
+                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Initialize_property_0_in_the_constructor), [tokenName]),
+                    changes: propertyInitializationChangeTracker.getChanges()
+                };
+
+                (actions || (actions = [])).push(initializeAction);
+                return actions;
             }
         }
 
-        function getActionsForAddMissingMemberInTypeScriptFile(): CodeAction[] | undefined {
-            let typeNode: TypeNode;
+        function getActionsForAddMissingMemberInTypeScriptFile(classDeclaration: ClassLikeDeclaration, makeStatic: boolean): CodeAction[] | undefined {
+            let actions: CodeAction[];
 
-            if (token.parent.parent.kind === SyntaxKind.BinaryExpression) {
-                const binaryExpression = token.parent.parent as BinaryExpression;
-
-                const checker = context.program.getTypeChecker();
-                const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(binaryExpression.right)));
-                typeNode = checker.typeToTypeNode(widenedType, classDeclaration);
+            const methodCodeAction = getActionForMethodDeclaration(/*includeTypeScriptSyntax*/ true);
+            if (methodCodeAction) {
+                actions = [methodCodeAction];
             }
 
+            let typeNode: TypeNode;
+            if (token.parent.parent.kind === SyntaxKind.BinaryExpression) {
+                const binaryExpression = token.parent.parent as BinaryExpression;
+                const otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left;
+                const checker = context.program.getTypeChecker();
+                const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression)));
+                typeNode = checker.typeToTypeNode(widenedType, classDeclaration);
+            }
             typeNode = typeNode || createKeywordTypeNode(SyntaxKind.AnyKeyword);
 
-            const openBrace = getOpenBraceOfClassLike(classDeclaration, sourceFile);
-
             const property = createProperty(
                 /*decorators*/undefined,
-                /*modifiers*/ isStatic ? [createToken(SyntaxKind.StaticKeyword)] : undefined,
-                token.getText(sourceFile),
+                /*modifiers*/ makeStatic ? [createToken(SyntaxKind.StaticKeyword)] : undefined,
+                tokenName,
                 /*questionToken*/ undefined,
                 typeNode,
                 /*initializer*/ undefined);
             const propertyChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context);
-            propertyChangeTracker.insertNodeAfter(sourceFile, openBrace, property, { suffix: context.newLineCharacter });
+            propertyChangeTracker.insertNodeAfter(classDeclarationSourceFile, classOpenBrace, property, { suffix: context.newLineCharacter });
 
-            const actions = [{
-                description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_declaration_for_missing_property_0), [token.getText()]),
+            (actions || (actions = [])).push({
+                description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Declare_property_0), [tokenName]),
                 changes: propertyChangeTracker.getChanges()
-            }];
+            });
 
-            if (!isStatic) {
+            if (!makeStatic) {
+                // Index signatures cannot have the static modifier.
                 const stringTypeNode = createKeywordTypeNode(SyntaxKind.StringKeyword);
                 const indexingParameter = createParameter(
                     /*decorators*/ undefined,
@@ -125,15 +179,32 @@ namespace ts.codefix {
                     typeNode);
 
                 const indexSignatureChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context);
-                indexSignatureChangeTracker.insertNodeAfter(sourceFile, openBrace, indexSignature, { suffix: context.newLineCharacter });
+                indexSignatureChangeTracker.insertNodeAfter(classDeclarationSourceFile, classOpenBrace, indexSignature, { suffix: context.newLineCharacter });
 
                 actions.push({
-                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_index_signature_for_missing_property_0), [token.getText()]),
+                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Add_index_signature_for_property_0), [tokenName]),
                     changes: indexSignatureChangeTracker.getChanges()
                 });
             }
 
             return actions;
         }
+
+        function getActionForMethodDeclaration(includeTypeScriptSyntax: boolean): CodeAction | undefined {
+            if (token.parent.parent.kind === SyntaxKind.CallExpression) {
+                const callExpression = <CallExpression>token.parent.parent;
+                const methodDeclaration = createMethodFromCallExpression(callExpression, tokenName, includeTypeScriptSyntax, makeStatic);
+
+                const methodDeclarationChangeTracker = textChanges.ChangeTracker.fromCodeFixContext(context);
+                methodDeclarationChangeTracker.insertNodeAfter(classDeclarationSourceFile, classOpenBrace, methodDeclaration, { suffix: context.newLineCharacter });
+                return {
+                    description: formatStringFromArgs(getLocaleSpecificMessage(makeStatic ?
+                        Diagnostics.Declare_method_0 :
+                        Diagnostics.Declare_static_method_0),
+                        [tokenName]),
+                    changes: methodDeclarationChangeTracker.getChanges()
+                };
+            }
+        }
     }
 }
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
index 39d8e13dde9..81aae4c0e5e 100644
--- a/src/services/codefixes/helpers.ts
+++ b/src/services/codefixes/helpers.ts
@@ -142,6 +142,50 @@ namespace ts.codefix {
         }
     }
 
+    export function createMethodFromCallExpression(callExpression: CallExpression, methodName: string, includeTypeScriptSyntax: boolean, makeStatic: boolean): MethodDeclaration {
+        const parameters = createDummyParameters(callExpression.arguments.length, /*names*/ undefined, /*minArgumentCount*/ undefined, includeTypeScriptSyntax);
+
+        let typeParameters: TypeParameterDeclaration[];
+        if (includeTypeScriptSyntax) {
+            const typeArgCount = length(callExpression.typeArguments);
+            for (let i = 0; i < typeArgCount; i++) {
+                const name = typeArgCount < 8 ? String.fromCharCode(CharacterCodes.T + i) : `T${i}`;
+                const typeParameter = createTypeParameterDeclaration(name, /*constraint*/ undefined, /*defaultType*/ undefined);
+                (typeParameters ? typeParameters : typeParameters = []).push(typeParameter);
+            }
+        }
+
+        const newMethod = createMethod(
+            /*decorators*/ undefined,
+            /*modifiers*/ makeStatic ? [createToken(SyntaxKind.StaticKeyword)] : undefined,
+            /*asteriskToken*/ undefined,
+            methodName,
+            /*questionToken*/ undefined,
+            typeParameters,
+            parameters,
+            /*type*/ includeTypeScriptSyntax ? createKeywordTypeNode(SyntaxKind.AnyKeyword) : undefined,
+            createStubbedMethodBody()
+        );
+        return newMethod;
+    }
+
+    function createDummyParameters(argCount: number,  names: string[] | undefined, minArgumentCount: number | undefined, addAnyType: boolean) {
+        const parameters: ParameterDeclaration[] = [];
+        for (let i = 0; i < argCount; i++) {
+            const newParameter = createParameter(
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
+                /*dotDotDotToken*/ undefined,
+                /*name*/ names && names[i] || `arg${i}`,
+                /*questionToken*/ minArgumentCount !== undefined && i >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined,
+                /*type*/ addAnyType ? createKeywordTypeNode(SyntaxKind.AnyKeyword) : undefined,
+                /*initializer*/ undefined);
+            parameters.push(newParameter);
+        }
+
+        return parameters;
+    }
+
     function createMethodImplementingSignatures(signatures: Signature[], name: PropertyName, optional: boolean, modifiers: Modifier[] | undefined): MethodDeclaration {
         /** This is *a* signature with the maximal number of arguments,
          * such that if there is a "maximal" signature without rest arguments,
@@ -163,19 +207,7 @@ namespace ts.codefix {
         const maxNonRestArgs = maxArgsSignature.parameters.length - (maxArgsSignature.hasRestParameter ? 1 : 0);
         const maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(symbol => symbol.getName());
 
-        const parameters: ParameterDeclaration[] = [];
-        for (let i = 0; i < maxNonRestArgs; i++) {
-            const anyType = createKeywordTypeNode(SyntaxKind.AnyKeyword);
-            const newParameter = createParameter(
-                /*decorators*/ undefined,
-                /*modifiers*/ undefined,
-                /*dotDotDotToken*/ undefined,
-                maxArgsParameterSymbolNames[i],
-                /*questionToken*/ i >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined,
-                anyType,
-                /*initializer*/ undefined);
-            parameters.push(newParameter);
-        }
+        const parameters = createDummyParameters(maxNonRestArgs, maxArgsParameterSymbolNames, minArgumentCount, /*addAnyType*/ true);
 
         if (someSigHasRestParameter) {
             const anyArrayType = createArrayTypeNode(createKeywordTypeNode(SyntaxKind.AnyKeyword));
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 53ec99fac81..c2d26da4392 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -138,8 +138,23 @@ namespace ts.codefix {
 
         const currentTokenMeaning = getMeaningFromLocation(token);
         if (context.errorCode === Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
-            const symbol = checker.getAliasedSymbol(checker.getSymbolAtLocation(token));
-            return getCodeActionForImport(symbol, /*isDefault*/ false, /*isNamespaceImport*/ true);
+            const umdSymbol = checker.getSymbolAtLocation(token);
+            let symbol: ts.Symbol;
+            let symbolName: string;
+            if (umdSymbol.flags & ts.SymbolFlags.Alias) {
+                symbol = checker.getAliasedSymbol(umdSymbol);
+                symbolName = name;
+            }
+            else if (isJsxOpeningLikeElement(token.parent) && token.parent.tagName === token) {
+                // The error wasn't for the symbolAtLocation, it was for the JSX tag itself, which needs access to e.g. `React`.
+                symbol = checker.getAliasedSymbol(checker.resolveNameAtLocation(token, checker.getJsxNamespace(), SymbolFlags.Value));
+                symbolName = symbol.name;
+            }
+            else {
+                Debug.fail("Either the symbol or the JSX namespace should be a UMD global if we got here");
+            }
+
+            return getCodeActionForImport(symbol, symbolName, /*isDefault*/ false, /*isNamespaceImport*/ true);
         }
 
         const candidateModules = checker.getAmbientModules();
@@ -159,7 +174,7 @@ namespace ts.codefix {
                 if (localSymbol && localSymbol.name === name && checkSymbolHasMeaning(localSymbol, currentTokenMeaning)) {
                     // check if this symbol is already used
                     const symbolId = getUniqueSymbolId(localSymbol);
-                    symbolIdActionMap.addActions(symbolId, getCodeActionForImport(moduleSymbol, /*isDefault*/ true));
+                    symbolIdActionMap.addActions(symbolId, getCodeActionForImport(moduleSymbol, name, /*isDefault*/ true));
                 }
             }
 
@@ -167,7 +182,7 @@ namespace ts.codefix {
             const exportSymbolWithIdenticalName = checker.tryGetMemberInModuleExports(name, moduleSymbol);
             if (exportSymbolWithIdenticalName && checkSymbolHasMeaning(exportSymbolWithIdenticalName, currentTokenMeaning)) {
                 const symbolId = getUniqueSymbolId(exportSymbolWithIdenticalName);
-                symbolIdActionMap.addActions(symbolId, getCodeActionForImport(moduleSymbol));
+                symbolIdActionMap.addActions(symbolId, getCodeActionForImport(moduleSymbol, name));
             }
         }
 
@@ -218,7 +233,7 @@ namespace ts.codefix {
             return declarations ? some(symbol.declarations, decl => !!(getMeaningFromDeclaration(decl) & meaning)) : false;
         }
 
-        function getCodeActionForImport(moduleSymbol: Symbol, isDefault?: boolean, isNamespaceImport?: boolean): ImportCodeAction[] {
+        function getCodeActionForImport(moduleSymbol: Symbol, symbolName: string, isDefault?: boolean, isNamespaceImport?: boolean): ImportCodeAction[] {
             const existingDeclarations = getImportDeclarations(moduleSymbol);
             if (existingDeclarations.length > 0) {
                 // With an existing import statement, there are more than one actions the user can do.
@@ -375,10 +390,10 @@ namespace ts.codefix {
                 const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier || getModuleSpecifierForNewImport());
                 const changeTracker = createChangeTracker();
                 const importClause = isDefault
-                    ? createImportClause(createIdentifier(name), /*namedBindings*/ undefined)
+                    ? createImportClause(createIdentifier(symbolName), /*namedBindings*/ undefined)
                     : isNamespaceImport
-                        ? createImportClause(/*name*/ undefined, createNamespaceImport(createIdentifier(name)))
-                        : createImportClause(/*name*/ undefined, createNamedImports([createImportSpecifier(/*propertyName*/ undefined, createIdentifier(name))]));
+                        ? createImportClause(/*name*/ undefined, createNamespaceImport(createIdentifier(symbolName)))
+                        : createImportClause(/*name*/ undefined, createNamedImports([createImportSpecifier(/*propertyName*/ undefined, createIdentifier(symbolName))]));
                 const importDecl = createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, importClause, createLiteral(moduleSpecifierWithoutQuotes));
                 if (!lastImportDeclaration) {
                     changeTracker.insertNodeAt(sourceFile, sourceFile.getStart(), importDecl, { suffix: `${context.newLineCharacter}${context.newLineCharacter}` });
@@ -392,7 +407,7 @@ namespace ts.codefix {
                 // are there are already a new line seperating code and import statements.
                 return createCodeAction(
                     Diagnostics.Import_0_from_1,
-                    [name, `"${moduleSpecifierWithoutQuotes}"`],
+                    [symbolName, `"${moduleSpecifierWithoutQuotes}"`],
                     changeTracker.getChanges(),
                     "NewImport",
                     moduleSpecifierWithoutQuotes
@@ -412,8 +427,9 @@ namespace ts.codefix {
                         removeFileExtension(getRelativePath(moduleFileName, sourceDirectory));
 
                     function tryGetModuleNameFromAmbientModule(): string {
-                        if (moduleSymbol.valueDeclaration.kind !== SyntaxKind.SourceFile) {
-                            return moduleSymbol.name;
+                        const decl = moduleSymbol.valueDeclaration;
+                        if (isModuleDeclaration(decl) && isStringLiteral(decl.name)) {
+                            return decl.name.text;
                         }
                     }
 
diff --git a/src/services/completions.ts b/src/services/completions.ts
index a895be8a7da..71fe4ce1c78 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -20,6 +20,22 @@ namespace ts.Completions {
 
         const { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, requestJsDocTagName, requestJsDocTag, hasFilteredClassMemberKeywords } = completionData;
 
+        if (sourceFile.languageVariant === LanguageVariant.JSX &&
+            location && location.parent && location.parent.kind === SyntaxKind.JsxClosingElement) {
+            // In the TypeScript JSX element, if such element is not defined. When users query for completion at closing tag,
+            // instead of simply giving unknown value, the completion will return the tag-name of an associated opening-element.
+            // For example:
+            //     var x = <div> </ /*1*/>  completion list at "1" will contain "div" with type any
+            const tagName = (<JsxElement>location.parent.parent).openingElement.tagName;
+            return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false,
+                entries: [{
+                    name: (<JsxTagNameExpression>tagName).getFullText(),
+                    kind: ScriptElementKind.classElement,
+                    kindModifiers: undefined,
+                    sortText: "0",
+                }]};
+        }
+
         if (requestJsDocTagName) {
             // If the current position is a jsDoc tag name, only tag names should be provided for completion
             return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: JsDoc.getJSDocTagNameCompletions() };
@@ -38,21 +54,7 @@ namespace ts.Completions {
         }
         else {
             if (!symbols || symbols.length === 0) {
-                if (sourceFile.languageVariant === LanguageVariant.JSX &&
-                    location.parent && location.parent.kind === SyntaxKind.JsxClosingElement) {
-                    // In the TypeScript JSX element, if such element is not defined. When users query for completion at closing tag,
-                    // instead of simply giving unknown value, the completion will return the tag-name of an associated opening-element.
-                    // For example:
-                    //     var x = <div> </ /*1*/>  completion list at "1" will contain "div" with type any
-                    const tagName = (<JsxElement>location.parent.parent).openingElement.tagName;
-                    entries.push({
-                        name: (<Identifier>tagName).text,
-                        kind: undefined,
-                        kindModifiers: undefined,
-                        sortText: "0",
-                    });
-                }
-                else if (!hasFilteredClassMemberKeywords) {
+                if (!hasFilteredClassMemberKeywords) {
                     return undefined;
                 }
             }
@@ -495,7 +497,7 @@ namespace ts.Completions {
                             // It has a left-hand side, so we're not in an opening JSX tag.
                             break;
                         }
-                        // falls through
+                    // falls through
 
                     case SyntaxKind.JsxSelfClosingElement:
                     case SyntaxKind.JsxElement:
@@ -1050,7 +1052,7 @@ namespace ts.Completions {
                     default:
                         if (isFromClassElementDeclaration(contextToken) &&
                             (isClassMemberCompletionKeyword(contextToken.kind) ||
-                            isClassMemberCompletionKeywordText(contextToken.getText()))) {
+                                isClassMemberCompletionKeywordText(contextToken.getText()))) {
                             return contextToken.parent.parent as ClassLikeDeclaration;
                         }
                 }
@@ -1213,7 +1215,7 @@ namespace ts.Completions {
                     if (isFromClassElementDeclaration(contextToken)) {
                         return false;
                     }
-                    // falls through
+                // falls through
                 case SyntaxKind.ClassKeyword:
                 case SyntaxKind.EnumKeyword:
                 case SyntaxKind.InterfaceKeyword:
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index df499cbd38a..c1a7408fae7 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -185,7 +185,8 @@ namespace ts.FindAllReferences {
         if (entry.type === "node") {
             const { node } = entry;
             return { textSpan: getTextSpan(node), fileName: node.getSourceFile().fileName, ...implementationKindDisplayParts(node, checker) };
-        } else {
+        }
+        else {
             const { textSpan, fileName } = entry;
             return { textSpan, fileName, kind: ScriptElementKind.unknown, displayParts: [] };
         }
diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts
index f20c80c14ef..585af7ebd31 100644
--- a/src/services/importTracker.ts
+++ b/src/services/importTracker.ts
@@ -530,7 +530,8 @@ namespace ts.FindAllReferences {
         if (parent.kind === SyntaxKind.VariableDeclaration) {
             const p = parent as ts.VariableDeclaration;
             return p.parent.kind === ts.SyntaxKind.CatchClause ? undefined : p.parent.parent.kind === SyntaxKind.VariableStatement ? p.parent.parent : undefined;
-        } else {
+        }
+        else {
             return parent;
         }
     }
diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts
index f601c9604de..5e31d6a0190 100644
--- a/src/services/jsTyping.ts
+++ b/src/services/jsTyping.ts
@@ -143,7 +143,7 @@ namespace ts.JsTyping {
         /**
          * Merge a given list of typingNames to the inferredTypings map
          */
-        function mergeTypings(typingNames: string[]) {
+        function mergeTypings(typingNames: ReadonlyArray<string>) {
             if (!typingNames) {
                 return;
             }
@@ -192,7 +192,7 @@ namespace ts.JsTyping {
             const cleanedTypingNames = map(inferredTypingNames, f => f.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, ""));
 
             if (safeList !== EmptySafeList) {
-                mergeTypings(filter(cleanedTypingNames, f => safeList.has(f)));
+                mergeTypings(ts.mapDefined(cleanedTypingNames, f => safeList.get(f)));
             }
 
             const hasJsxFile = forEach(fileNames, f => ensureScriptKind(f, getScriptKindFromFileName(f)) === ScriptKind.JSX);
diff --git a/src/services/refactorProvider.ts b/src/services/refactorProvider.ts
index 0b6ea3487ec..1058f9c2ca6 100644
--- a/src/services/refactorProvider.ts
+++ b/src/services/refactorProvider.ts
@@ -52,18 +52,8 @@ namespace ts {
         }
 
         export function getRefactorCodeActions(context: RefactorContext, refactorName: string): CodeAction[] | undefined {
-
-            let result: CodeAction[];
             const refactor = refactors.get(refactorName);
-            if (!refactor) {
-                return undefined;
-            }
-
-            const codeActions = refactor.getCodeActions(context);
-            if (codeActions) {
-                addRange((result || (result = [])), codeActions);
-            }
-            return result;
+            return refactor && refactor.getCodeActions(context);
         }
     }
 }
diff --git a/src/services/services.ts b/src/services/services.ts
index 05fe59084b4..21c756a9acc 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -368,7 +368,7 @@ namespace ts {
         _primaryExpressionBrand: any;
         _memberExpressionBrand: any;
         _leftHandSideExpressionBrand: any;
-        _incrementExpressionBrand: any;
+        _updateExpressionBrand: any;
         _unaryExpressionBrand: any;
         _expressionBrand: any;
         /*@internal*/typeArguments: NodeArray<TypeNode>;
@@ -521,6 +521,7 @@ namespace ts {
         private namedDeclarations: Map<Declaration[]>;
         public ambientModuleNames: string[];
         public checkJsDirective: CheckJsDirective | undefined;
+        public possiblyContainDynamicImport: boolean;
 
         constructor(kind: SyntaxKind, pos: number, end: number) {
             super(kind, pos, end);
diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols
index 6f02cdcf963..8d6b6b167e6 100644
--- a/tests/baselines/reference/2dArrays.symbols
+++ b/tests/baselines/reference/2dArrays.symbols
@@ -25,11 +25,11 @@ class Board {
 >allShipsSunk : Symbol(Board.allShipsSunk, Decl(2dArrays.ts, 9, 18))
 
         return this.ships.every(function (val) { return val.isSunk; });
->this.ships.every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>this.ships.every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >this.ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
 >ships : Symbol(Board.ships, Decl(2dArrays.ts, 7, 13))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
diff --git a/tests/baselines/reference/2dArrays.types b/tests/baselines/reference/2dArrays.types
index 45672187306..00805899294 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: 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.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
 >this.ships : Ship[]
 >this : this
 >ships : Ship[]
->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
+>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>function (val) { return val.isSunk; } : (val: Ship) => boolean
 >val : Ship
 >val.isSunk : boolean
 >val : Ship
diff --git a/tests/baselines/reference/APISample_watcher.js b/tests/baselines/reference/APISample_watcher.js
index b813a44f53e..f4d03f8f62f 100644
--- a/tests/baselines/reference/APISample_watcher.js
+++ b/tests/baselines/reference/APISample_watcher.js
@@ -11,7 +11,7 @@ declare var fs: {
     existsSync(path: string): boolean;
     readdirSync(path: string): string[];
     readFileSync(filename: string, encoding?: string): string;
-    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; } | string): void;
     watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: { mtime: Date }, prev: { mtime: Date }) => void): void;
 };
 declare var path: any;
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
index 750c7ba85af..c1b5df88fb0 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
@@ -35,16 +35,16 @@ paired.reduce((b3, b4) => b3.concat({}), []);
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 
 paired.map((c1) => c1.count);
->paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 
 paired.map(function (c2) { return c2.count; });
->paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.types b/tests/baselines/reference/anyInferenceAnonymousFunctions.types
index b015d350760..8dc7fdcb90f 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: 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.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >paired : 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
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>(c1) => c1.count : (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: 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.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >paired : 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
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>function (c2) { return c2.count; } : (c2: any) => any
 >c2 : any
 >c2.count : any
 >c2 : any
diff --git a/tests/baselines/reference/argumentsAsPropertyName.symbols b/tests/baselines/reference/argumentsAsPropertyName.symbols
index a17c660374c..1e3e41abb6e 100644
--- a/tests/baselines/reference/argumentsAsPropertyName.symbols
+++ b/tests/baselines/reference/argumentsAsPropertyName.symbols
@@ -34,8 +34,8 @@ function myFunction(myType: MyType) {
 >x : Symbol(x, Decl(argumentsAsPropertyName.ts, 11, 13))
 
         [1, 2, 3].forEach(function(j) { use(x); })
->[1, 2, 3].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1, 2, 3].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >j : Symbol(j, Decl(argumentsAsPropertyName.ts, 12, 35))
 >use : Symbol(use, Decl(argumentsAsPropertyName.ts, 3, 1))
 >x : Symbol(x, Decl(argumentsAsPropertyName.ts, 11, 13))
diff --git a/tests/baselines/reference/argumentsAsPropertyName.types b/tests/baselines/reference/argumentsAsPropertyName.types
index 73397199436..d0aaaa1cc72 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: 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].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 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; }
->function(j) { use(x); } : (this: void, j: number) => void
+>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>function(j) { use(x); } : (j: number) => void
 >j : number
 >use(x) : any
 >use : (s: any) => any
diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols
index 1b26708ae94..5ef9d811723 100644
--- a/tests/baselines/reference/arrayConcatMap.symbols
+++ b/tests/baselines/reference/arrayConcatMap.symbols
@@ -1,14 +1,14 @@
 === tests/cases/compiler/arrayConcatMap.ts ===
 var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >x : Symbol(x, Decl(arrayConcatMap.ts, 0, 3))
->[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >[].concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32))
 
           .map(b => b.a);
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 
diff --git a/tests/baselines/reference/arrayConcatMap.types b/tests/baselines/reference/arrayConcatMap.types
index b234b7beb26..89289e58d4e 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: 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 }])          .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => 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: 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
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>b => b.a : (b: any) => any
 >b : any
 >b.a : any
 >b : any
diff --git a/tests/baselines/reference/arrayFilter.symbols b/tests/baselines/reference/arrayFilter.symbols
index 81d92ba04b6..cba8f48c89f 100644
--- a/tests/baselines/reference/arrayFilter.symbols
+++ b/tests/baselines/reference/arrayFilter.symbols
@@ -14,9 +14,9 @@ var foo = [
 ]
 
 foo.filter(x => x.name); //should accepted all possible types not only boolean! 
->foo.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>foo.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >foo : Symbol(foo, Decl(arrayFilter.ts, 0, 3))
->filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(arrayFilter.ts, 6, 11))
 >x.name : Symbol(name, Decl(arrayFilter.ts, 1, 5))
 >x : Symbol(x, Decl(arrayFilter.ts, 6, 11))
diff --git a/tests/baselines/reference/arrayFilter.types b/tests/baselines/reference/arrayFilter.types
index 23ab4d915bd..7d91ef4ed32 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: 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.filter : { <S extends { name: string; }>(callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
 >foo : { name: 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
+>filter : { <S extends { name: string; }>(callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
+>x => x.name : (x: { name: string; }) => string
 >x : { name: string; }
 >x.name : string
 >x : { name: string; }
diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
index 90dc909b11a..df24be3a020 100644
--- a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
+++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
   Types of property 'concat' are incompatible.
-    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
       Type 'A[]' is not assignable to type 'B[]'.
         Type 'A' is not assignable to type 'B'.
           Property 'b' is missing in type 'A'.
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
   Types of property 'concat' are incompatible.
-    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
       Type 'A[]' is not assignable to type 'B[]'.
 
 
@@ -27,7 +27,7 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
     ~~~
 !!! error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
 !!! error TS2322:   Types of property 'concat' are incompatible.
-!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
 !!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
 !!! error TS2322:         Type 'A' is not assignable to type 'B'.
 !!! error TS2322:           Property 'b' is missing in type 'A'.
@@ -39,6 +39,6 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
     ~~~
 !!! error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
 !!! error TS2322:   Types of property 'concat' are incompatible.
-!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
 !!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.errors.txt b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.errors.txt
index de2751beaca..0d7fe1071e9 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.errors.txt
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.errors.txt
@@ -1,3 +1,12 @@
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(33,5): error TS2559: Type 'D' has no properties in common with type 'C'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(34,5): error TS2559: Type 'E' has no properties in common with type 'C'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(35,5): error TS2559: Type 'F' has no properties in common with type 'C'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(36,5): error TS2559: Type 'D' has no properties in common with type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(37,5): error TS2559: Type 'E' has no properties in common with type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(38,5): error TS2559: Type 'F' has no properties in common with type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(39,5): error TS2559: Type 'D' has no properties in common with type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(40,5): error TS2559: Type 'E' has no properties in common with type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(41,5): error TS2559: Type 'F' has no properties in common with type '{ opt?: Base; }'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(74,5): error TS2322: Type 'D' is not assignable to type 'C'.
   Property 'opt' is missing in type 'D'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(75,5): error TS2322: Type 'E' is not assignable to type 'C'.
@@ -18,7 +27,7 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
   Property 'opt' is missing in type 'F'.
 
 
-==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts (9 errors) ====
+==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts (18 errors) ====
     // M is optional and S contains no property with the same name as M
     // N is optional and T contains no property with the same name as N
     
@@ -50,20 +59,38 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
         var e: E;
         var f: F;
     
-        // all ok
+        // disallowed by weak type checking
         c = d;
+        ~
+!!! error TS2559: Type 'D' has no properties in common with type 'C'.
         c = e;
+        ~
+!!! error TS2559: Type 'E' has no properties in common with type 'C'.
         c = f;
-        c = a;
-    
+        ~
+!!! error TS2559: Type 'F' has no properties in common with type 'C'.
         a = d;
+        ~
+!!! error TS2559: Type 'D' has no properties in common with type '{ opt?: Base; }'.
         a = e;
+        ~
+!!! error TS2559: Type 'E' has no properties in common with type '{ opt?: Base; }'.
         a = f;
-        a = c;
-    
+        ~
+!!! error TS2559: Type 'F' has no properties in common with type '{ opt?: Base; }'.
         b = d;
+        ~
+!!! error TS2559: Type 'D' has no properties in common with type '{ opt?: Base; }'.
         b = e;
+        ~
+!!! error TS2559: Type 'E' has no properties in common with type '{ opt?: Base; }'.
         b = f;
+        ~
+!!! error TS2559: Type 'F' has no properties in common with type '{ opt?: Base; }'.
+    
+        // ok
+        c = a;
+        a = c;
         b = a;
         b = c;
     }
@@ -134,4 +161,5 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
 !!! error TS2322:   Property 'opt' is missing in type 'F'.
         b = a; // ok
         b = c; // ok
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.js b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.js
index e158a787878..d83f3182531 100644
--- a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.js
+++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.js
@@ -30,20 +30,20 @@ module TargetHasOptional {
     var e: E;
     var f: F;
 
-    // all ok
+    // disallowed by weak type checking
     c = d;
     c = e;
     c = f;
-    c = a;
-
     a = d;
     a = e;
     a = f;
-    a = c;
-
     b = d;
     b = e;
     b = f;
+
+    // ok
+    c = a;
+    a = c;
     b = a;
     b = c;
 }
@@ -87,7 +87,8 @@ module SourceHasOptional {
     b = f; // error
     b = a; // ok
     b = c; // ok
-}
+}
+
 
 //// [assignmentCompatWithObjectMembersOptionality2.js]
 // M is optional and S contains no property with the same name as M
@@ -129,18 +130,19 @@ var TargetHasOptional;
     var d;
     var e;
     var f;
-    // all ok
+    // disallowed by weak type checking
     c = d;
     c = e;
     c = f;
-    c = a;
     a = d;
     a = e;
     a = f;
-    a = c;
     b = d;
     b = e;
     b = f;
+    // ok
+    c = a;
+    a = c;
     b = a;
     b = c;
 })(TargetHasOptional || (TargetHasOptional = {}));
diff --git a/tests/baselines/reference/bestChoiceType.symbols b/tests/baselines/reference/bestChoiceType.symbols
index dc4ea663efc..c65dba1e7c2 100644
--- a/tests/baselines/reference/bestChoiceType.symbols
+++ b/tests/baselines/reference/bestChoiceType.symbols
@@ -2,10 +2,10 @@
 // Repro from #10041
 
 (''.match(/ /) || []).map(s => s.toLowerCase());
->(''.match(/ /) || []).map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>(''.match(/ /) || []).map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >''.match : Symbol(String.match, Decl(lib.d.ts, --, --))
 >match : Symbol(String.match, Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 2, 26))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 2, 26))
@@ -27,9 +27,9 @@ function f1() {
 
     let z = y.map(s => s.toLowerCase());
 >z : Symbol(z, Decl(bestChoiceType.ts, 9, 7))
->y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>y.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(bestChoiceType.ts, 8, 7))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 9, 18))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 9, 18))
@@ -51,9 +51,9 @@ function f2() {
 
     let z = y.map(s => s.toLowerCase());
 >z : Symbol(z, Decl(bestChoiceType.ts, 15, 7))
->y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>y.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(bestChoiceType.ts, 14, 7))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 15, 18))
 >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(bestChoiceType.ts, 15, 18))
diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types
index 15c5ecd4858..49997d1e273 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: 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(/ /) || []).map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => 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: 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
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s => s.toLowerCase() : (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: 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.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >y : RegExpMatchArray
->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
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s => s.toLowerCase() : (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: 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.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >y : RegExpMatchArray
->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
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s => s.toLowerCase() : (s: string) => string
 >s : string
 >s.toLowerCase() : string
 >s.toLowerCase : () => string
diff --git a/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.js b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.js
new file mode 100644
index 00000000000..b89943b24ff
--- /dev/null
+++ b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.js
@@ -0,0 +1,15 @@
+//// [tests/cases/compiler/blockScopedClassDeclarationAcrossFiles.ts] ////
+
+//// [c.ts]
+let foo: typeof C;
+//// [b.ts]
+class C { }
+
+
+//// [foo.js]
+var foo;
+var C = (function () {
+    function C() {
+    }
+    return C;
+}());
diff --git a/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.symbols b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.symbols
new file mode 100644
index 00000000000..c5c6e40da20
--- /dev/null
+++ b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.symbols
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/c.ts ===
+let foo: typeof C;
+>foo : Symbol(foo, Decl(c.ts, 0, 3))
+>C : Symbol(C, Decl(b.ts, 0, 0))
+
+=== tests/cases/compiler/b.ts ===
+class C { }
+>C : Symbol(C, Decl(b.ts, 0, 0))
+
diff --git a/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.types b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.types
new file mode 100644
index 00000000000..5bc8862b2aa
--- /dev/null
+++ b/tests/baselines/reference/blockScopedClassDeclarationAcrossFiles.types
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/c.ts ===
+let foo: typeof C;
+>foo : typeof C
+>C : typeof C
+
+=== tests/cases/compiler/b.ts ===
+class C { }
+>C : C
+
diff --git a/tests/baselines/reference/checkJsdocParamTag1.js b/tests/baselines/reference/checkJsdocParamTag1.js
new file mode 100644
index 00000000000..577460626a1
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocParamTag1.js
@@ -0,0 +1,22 @@
+//// [0.js]
+// @ts-check
+/**
+ * @param {number=} n
+ * @param {string} [s]
+ */
+function foo(n, s) {}
+
+foo();
+foo(1);
+foo(1, "hi");
+
+//// [0.js]
+// @ts-check
+/**
+ * @param {number=} n
+ * @param {string} [s]
+ */
+function foo(n, s) { }
+foo();
+foo(1);
+foo(1, "hi");
diff --git a/tests/baselines/reference/checkJsdocParamTag1.symbols b/tests/baselines/reference/checkJsdocParamTag1.symbols
new file mode 100644
index 00000000000..d16816f908b
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocParamTag1.symbols
@@ -0,0 +1,20 @@
+=== tests/cases/conformance/jsdoc/0.js ===
+// @ts-check
+/**
+ * @param {number=} n
+ * @param {string} [s]
+ */
+function foo(n, s) {}
+>foo : Symbol(foo, Decl(0.js, 0, 0))
+>n : Symbol(n, Decl(0.js, 5, 13))
+>s : Symbol(s, Decl(0.js, 5, 15))
+
+foo();
+>foo : Symbol(foo, Decl(0.js, 0, 0))
+
+foo(1);
+>foo : Symbol(foo, Decl(0.js, 0, 0))
+
+foo(1, "hi");
+>foo : Symbol(foo, Decl(0.js, 0, 0))
+
diff --git a/tests/baselines/reference/checkJsdocParamTag1.types b/tests/baselines/reference/checkJsdocParamTag1.types
new file mode 100644
index 00000000000..5b24c3d8887
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocParamTag1.types
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/jsdoc/0.js ===
+// @ts-check
+/**
+ * @param {number=} n
+ * @param {string} [s]
+ */
+function foo(n, s) {}
+>foo : (n?: number, s?: string) => void
+>n : number
+>s : string
+
+foo();
+>foo() : void
+>foo : (n?: number, s?: string) => void
+
+foo(1);
+>foo(1) : void
+>foo : (n?: number, s?: string) => void
+>1 : 1
+
+foo(1, "hi");
+>foo(1, "hi") : void
+>foo : (n?: number, s?: string) => void
+>1 : 1
+>"hi" : "hi"
+
diff --git a/tests/baselines/reference/checkJsdocReturnTag1.js b/tests/baselines/reference/checkJsdocReturnTag1.js
new file mode 100644
index 00000000000..31c30e54dfc
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag1.js
@@ -0,0 +1,43 @@
+//// [returns.js]
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return "hello";
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return "hello world";
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
+
+//// [dummy.js]
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return "hello";
+}
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return "hello world";
+}
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
diff --git a/tests/baselines/reference/checkJsdocReturnTag1.symbols b/tests/baselines/reference/checkJsdocReturnTag1.symbols
new file mode 100644
index 00000000000..ec6376d02ab
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag1.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : Symbol(f, Decl(returns.js, 0, 0))
+
+    return "hello";
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+>f1 : Symbol(f1, Decl(returns.js, 6, 1))
+
+    return "hello world";
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+>f2 : Symbol(f2, Decl(returns.js, 13, 1))
+
+    return 5 || "hello";
+}
diff --git a/tests/baselines/reference/checkJsdocReturnTag1.types b/tests/baselines/reference/checkJsdocReturnTag1.types
new file mode 100644
index 00000000000..04a2df87c01
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag1.types
@@ -0,0 +1,33 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : () => string
+
+    return "hello";
+>"hello" : "hello"
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+>f1 : () => string
+
+    return "hello world";
+>"hello world" : "hello world"
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+>f2 : () => string | number
+
+    return 5 || "hello";
+>5 || "hello" : "hello" | 5
+>5 : 5
+>"hello" : "hello"
+}
diff --git a/tests/baselines/reference/checkJsdocReturnTag2.js b/tests/baselines/reference/checkJsdocReturnTag2.js
new file mode 100644
index 00000000000..4a68e5d85b7
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag2.js
@@ -0,0 +1,30 @@
+//// [returns.js]
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+
+/**
+ * @returns {string | number} This comment is not currently exposed
+ */
+function f1() {
+    return 5 || true;
+}
+
+//// [dummy.js]
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+/**
+ * @returns {string | number} This comment is not currently exposed
+ */
+function f1() {
+    return 5 || true;
+}
diff --git a/tests/baselines/reference/checkJsdocReturnTag2.symbols b/tests/baselines/reference/checkJsdocReturnTag2.symbols
new file mode 100644
index 00000000000..43fa1a800e1
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag2.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : Symbol(f, Decl(returns.js, 0, 0))
+
+    return 5;
+}
+
+/**
+ * @returns {string | number} This comment is not currently exposed
+ */
+function f1() {
+>f1 : Symbol(f1, Decl(returns.js, 6, 1))
+
+    return 5 || true;
+}
diff --git a/tests/baselines/reference/checkJsdocReturnTag2.types b/tests/baselines/reference/checkJsdocReturnTag2.types
new file mode 100644
index 00000000000..fe7dca7a364
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocReturnTag2.types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : () => string
+
+    return 5;
+>5 : 5
+}
+
+/**
+ * @returns {string | number} This comment is not currently exposed
+ */
+function f1() {
+>f1 : () => string | number
+
+    return 5 || true;
+>5 || true : true | 5
+>5 : 5
+>true : true
+}
diff --git a/tests/baselines/reference/jsDocTypes2.js b/tests/baselines/reference/checkJsdocTypeTag1.js
similarity index 77%
rename from tests/baselines/reference/jsDocTypes2.js
rename to tests/baselines/reference/checkJsdocTypeTag1.js
index ba59043978c..e4586643c22 100644
--- a/tests/baselines/reference/jsDocTypes2.js
+++ b/tests/baselines/reference/checkJsdocTypeTag1.js
@@ -1,7 +1,14 @@
 //// [0.js]
 // @ts-check
+/** @type {String} */
+var S = "hello world";
+
+/** @type {number} */
+var n = 10;
+
 /** @type {*} */
 var anyT = 2;
+anyT = "hello";
 
 /** @type {?} */
 var anyT1 = 2;
@@ -25,8 +32,13 @@ x2(0);
 
 //// [0.js]
 // @ts-check
+/** @type {String} */
+var S = "hello world";
+/** @type {number} */
+var n = 10;
 /** @type {*} */
 var anyT = 2;
+anyT = "hello";
 /** @type {?} */
 var anyT1 = 2;
 anyT1 = "hi";
diff --git a/tests/baselines/reference/checkJsdocTypeTag1.symbols b/tests/baselines/reference/checkJsdocTypeTag1.symbols
new file mode 100644
index 00000000000..fff51499bc4
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocTypeTag1.symbols
@@ -0,0 +1,60 @@
+=== tests/cases/conformance/jsdoc/0.js ===
+// @ts-check
+/** @type {String} */
+var S = "hello world";
+>S : Symbol(S, Decl(0.js, 2, 3))
+
+/** @type {number} */
+var n = 10;
+>n : Symbol(n, Decl(0.js, 5, 3))
+
+/** @type {*} */
+var anyT = 2;
+>anyT : Symbol(anyT, Decl(0.js, 8, 3))
+
+anyT = "hello";
+>anyT : Symbol(anyT, Decl(0.js, 8, 3))
+
+/** @type {?} */
+var anyT1 = 2;
+>anyT1 : Symbol(anyT1, Decl(0.js, 12, 3))
+
+anyT1 = "hi";
+>anyT1 : Symbol(anyT1, Decl(0.js, 12, 3))
+
+/** @type {Function} */
+const x = (a) => a + 1;
+>x : Symbol(x, Decl(0.js, 16, 5))
+>a : Symbol(a, Decl(0.js, 16, 11))
+>a : Symbol(a, Decl(0.js, 16, 11))
+
+x(1);
+>x : Symbol(x, Decl(0.js, 16, 5))
+
+/** @type {function} */
+const y = (a) => a + 1;
+>y : Symbol(y, Decl(0.js, 20, 5))
+>a : Symbol(a, Decl(0.js, 20, 11))
+>a : Symbol(a, Decl(0.js, 20, 11))
+
+x(1);
+>x : Symbol(x, Decl(0.js, 16, 5))
+
+/** @type {function (number)} */
+const x1 = (a) => a + 1;
+>x1 : Symbol(x1, Decl(0.js, 24, 5))
+>a : Symbol(a, Decl(0.js, 24, 12))
+>a : Symbol(a, Decl(0.js, 24, 12))
+
+x1(0);
+>x1 : Symbol(x1, Decl(0.js, 24, 5))
+
+/** @type {function (number): number} */
+const x2 = (a) => a + 1;
+>x2 : Symbol(x2, Decl(0.js, 28, 5))
+>a : Symbol(a, Decl(0.js, 28, 12))
+>a : Symbol(a, Decl(0.js, 28, 12))
+
+x2(0);
+>x2 : Symbol(x2, Decl(0.js, 28, 5))
+
diff --git a/tests/baselines/reference/jsDocTypes2.types b/tests/baselines/reference/checkJsdocTypeTag1.types
similarity index 73%
rename from tests/baselines/reference/jsDocTypes2.types
rename to tests/baselines/reference/checkJsdocTypeTag1.types
index 599c19c7ffc..9368640edcb 100644
--- a/tests/baselines/reference/jsDocTypes2.types
+++ b/tests/baselines/reference/checkJsdocTypeTag1.types
@@ -1,10 +1,25 @@
-=== tests/cases/conformance/salsa/0.js ===
+=== tests/cases/conformance/jsdoc/0.js ===
 // @ts-check
+/** @type {String} */
+var S = "hello world";
+>S : string
+>"hello world" : "hello world"
+
+/** @type {number} */
+var n = 10;
+>n : number
+>10 : 10
+
 /** @type {*} */
 var anyT = 2;
 >anyT : any
 >2 : 2
 
+anyT = "hello";
+>anyT = "hello" : "hello"
+>anyT : any
+>"hello" : "hello"
+
 /** @type {?} */
 var anyT1 = 2;
 >anyT1 : any
diff --git a/tests/baselines/reference/checkJsdocTypeTag2.errors.txt b/tests/baselines/reference/checkJsdocTypeTag2.errors.txt
new file mode 100644
index 00000000000..ca02c578a36
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocTypeTag2.errors.txt
@@ -0,0 +1,42 @@
+tests/cases/conformance/jsdoc/0.js(3,5): error TS2322: Type 'true' is not assignable to type 'string'.
+tests/cases/conformance/jsdoc/0.js(6,5): error TS2322: Type '"hello"' is not assignable to type 'number'.
+tests/cases/conformance/jsdoc/0.js(10,4): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'.
+tests/cases/conformance/jsdoc/0.js(13,7): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/conformance/jsdoc/0.js(17,1): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/jsdoc/0.js(20,7): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+
+
+==== tests/cases/conformance/jsdoc/0.js (6 errors) ====
+    // @ts-check
+    /** @type {String} */
+    var S = true;
+        ~
+!!! error TS2322: Type 'true' is not assignable to type 'string'.
+    
+    /** @type {number} */
+    var n = "hello";
+        ~
+!!! error TS2322: Type '"hello"' is not assignable to type 'number'.
+    
+    /** @type {function (number)} */
+    const x1 = (a) => a + 1;
+    x1("string");
+       ~~~~~~~~
+!!! error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'.
+    
+    /** @type {function (number): number} */
+    const x2 = (a) => a + 1;
+          ~~
+!!! error TS2451: Cannot redeclare block-scoped variable 'x2'.
+    
+    /** @type {string} */
+    var a;
+    a = x2(0);
+    ~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    
+    /** @type {function (number): number} */
+    const x2 = (a) => a.concat("hi");
+          ~~
+!!! error TS2451: Cannot redeclare block-scoped variable 'x2'.
+    x2(0);
\ No newline at end of file
diff --git a/tests/baselines/reference/checkJsdocTypeTag2.js b/tests/baselines/reference/checkJsdocTypeTag2.js
new file mode 100644
index 00000000000..23b436e2031
--- /dev/null
+++ b/tests/baselines/reference/checkJsdocTypeTag2.js
@@ -0,0 +1,40 @@
+//// [0.js]
+// @ts-check
+/** @type {String} */
+var S = true;
+
+/** @type {number} */
+var n = "hello";
+
+/** @type {function (number)} */
+const x1 = (a) => a + 1;
+x1("string");
+
+/** @type {function (number): number} */
+const x2 = (a) => a + 1;
+
+/** @type {string} */
+var a;
+a = x2(0);
+
+/** @type {function (number): number} */
+const x2 = (a) => a.concat("hi");
+x2(0);
+
+//// [0.js]
+// @ts-check
+/** @type {String} */
+var S = true;
+/** @type {number} */
+var n = "hello";
+/** @type {function (number)} */
+var x1 = function (a) { return a + 1; };
+x1("string");
+/** @type {function (number): number} */
+var x2 = function (a) { return a + 1; };
+/** @type {string} */
+var a;
+a = x2(0);
+/** @type {function (number): number} */
+var x2 = function (a) { return a.concat("hi"); };
+x2(0);
diff --git a/tests/baselines/reference/jsDocTypes3.errors.txt b/tests/baselines/reference/checkJsdocTypeTag3.errors.txt
similarity index 72%
rename from tests/baselines/reference/jsDocTypes3.errors.txt
rename to tests/baselines/reference/checkJsdocTypeTag3.errors.txt
index 5f5feeaf0a7..d53c0972fa3 100644
--- a/tests/baselines/reference/jsDocTypes3.errors.txt
+++ b/tests/baselines/reference/checkJsdocTypeTag3.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/salsa/0.js(5,4): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'.
-tests/cases/conformance/salsa/0.js(12,1): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/jsdoc/0.js(5,4): error TS2345: Argument of type '"string"' is not assignable to parameter of type 'number'.
+tests/cases/conformance/jsdoc/0.js(12,1): error TS2322: Type 'number' is not assignable to type 'string'.
 
 
-==== tests/cases/conformance/salsa/0.js (2 errors) ====
+==== tests/cases/conformance/jsdoc/0.js (2 errors) ====
     // @ts-check
     
     /** @type {function (number)} */
diff --git a/tests/baselines/reference/jsDocTypes3.js b/tests/baselines/reference/checkJsdocTypeTag3.js
similarity index 100%
rename from tests/baselines/reference/jsDocTypes3.js
rename to tests/baselines/reference/checkJsdocTypeTag3.js
diff --git a/tests/baselines/reference/checkJsxChildrenProperty1.symbols b/tests/baselines/reference/checkJsxChildrenProperty1.symbols
index 8793d0edd49..ede60746f4b 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty1.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty1.symbols
@@ -13,8 +13,8 @@ interface Prop {
 
     children: string | JSX.Element
 >children : Symbol(Prop.children, Decl(file.tsx, 4, 14))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 }
 
 function Comp(p: Prop) {
@@ -23,11 +23,11 @@ function Comp(p: Prop) {
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     return <div>{p.b}</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 >p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
 >p : Symbol(p, Decl(file.tsx, 8, 14))
 >b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 // OK
@@ -59,8 +59,8 @@ let k2 =
 >b : Symbol(b, Decl(file.tsx, 19, 16))
 
         <div>hi hi hi!</div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     </Comp>;
 >Comp : Symbol(Comp, Decl(file.tsx, 6, 1))
diff --git a/tests/baselines/reference/checkJsxChildrenProperty12.symbols b/tests/baselines/reference/checkJsxChildrenProperty12.symbols
index ccfb4b18875..09080234ea9 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty12.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty12.symbols
@@ -18,9 +18,9 @@ interface ButtonProp {
 
 class Button extends React.Component<ButtonProp, any> {
 >Button : Symbol(Button, Decl(file.tsx, 6, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >ButtonProp : Symbol(ButtonProp, Decl(file.tsx, 0, 32))
 
     render() {
@@ -34,20 +34,20 @@ class Button extends React.Component<ButtonProp, any> {
 
         	return <InnerButton {...this.props} />
 >InnerButton : Symbol(InnerButton, Decl(file.tsx, 24, 1))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol(Button, Decl(file.tsx, 6, 1))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 		}
 		else {
 			return (<InnerButton {...this.props} >
 >InnerButton : Symbol(InnerButton, Decl(file.tsx, 24, 1))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol(Button, Decl(file.tsx, 6, 1))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 
 				<div>Hello World</div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 				</InnerButton>);
 >InnerButton : Symbol(InnerButton, Decl(file.tsx, 24, 1))
@@ -64,17 +64,17 @@ interface InnerButtonProp {
 
 class InnerButton extends React.Component<InnerButtonProp, any> {
 >InnerButton : Symbol(InnerButton, Decl(file.tsx, 24, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >InnerButtonProp : Symbol(InnerButtonProp, Decl(file.tsx, 20, 1))
 
 	render() {
 >render : Symbol(InnerButton.render, Decl(file.tsx, 26, 65))
 
 		return (<button>Hello</button>);
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 	}
 }
 
diff --git a/tests/baselines/reference/checkJsxChildrenProperty3.symbols b/tests/baselines/reference/checkJsxChildrenProperty3.symbols
index 49d146f07da..ea1beff75ac 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty3.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty3.symbols
@@ -16,34 +16,34 @@ interface IFetchUserProps {
 >children : Symbol(IFetchUserProps.children, Decl(file.tsx, 6, 27))
 >user : Symbol(user, Decl(file.tsx, 7, 15))
 >IUser : Symbol(IUser, Decl(file.tsx, 0, 32))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 }
 
 class FetchUser extends React.Component<IFetchUserProps, any> {
 >FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >IFetchUserProps : Symbol(IFetchUserProps, Decl(file.tsx, 4, 1))
 
     render() {
 >render : Symbol(FetchUser.render, Decl(file.tsx, 10, 63))
 
         return this.state
->this.state : Symbol(React.Component.state, Decl(react.d.ts, 173, 44))
+>this.state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44))
 >this : Symbol(FetchUser, Decl(file.tsx, 8, 1))
->state : Symbol(React.Component.state, Decl(react.d.ts, 173, 44))
+>state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44))
 
             ? this.props.children(this.state.result)
->this.props.children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 173, 20))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props.children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 174, 20))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol(FetchUser, Decl(file.tsx, 8, 1))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
->children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 173, 20))
->this.state : Symbol(React.Component.state, Decl(react.d.ts, 173, 44))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
+>children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 174, 20))
+>this.state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44))
 >this : Symbol(FetchUser, Decl(file.tsx, 8, 1))
->state : Symbol(React.Component.state, Decl(react.d.ts, 173, 44))
+>state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44))
 
             : null;
     }
@@ -61,11 +61,11 @@ function UserName0() {
 >user : Symbol(user, Decl(file.tsx, 22, 13))
 
                 <h1>{ user.Name }</h1>
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 >user.Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17))
 >user : Symbol(user, Decl(file.tsx, 22, 13))
 >Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 
             ) }
         </FetchUser>
@@ -85,11 +85,11 @@ function UserName1() {
 >user : Symbol(user, Decl(file.tsx, 33, 13))
 
                 <h1>{ user.Name }</h1>
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 >user.Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17))
 >user : Symbol(user, Decl(file.tsx, 33, 13))
 >Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 
             ) }
         </FetchUser>
diff --git a/tests/baselines/reference/checkJsxChildrenProperty6.symbols b/tests/baselines/reference/checkJsxChildrenProperty6.symbols
index e69b24a89ab..3fc70d41883 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty6.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty6.symbols
@@ -13,24 +13,24 @@ interface Prop {
 
     children: JSX.Element | JSX.Element[];
 >children : Symbol(Prop.children, Decl(file.tsx, 4, 14))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 }
 
 class Button extends React.Component<any, any> {
 >Button : Symbol(Button, Decl(file.tsx, 6, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(Button.render, Decl(file.tsx, 8, 48))
 
         return (<div>My Button</div>)
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
@@ -39,8 +39,8 @@ function AnotherButton(p: any) {
 >p : Symbol(p, Decl(file.tsx, 14, 23))
 
     return <h1>Just Another Button</h1>;
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 }
 
 function Comp(p: Prop) {
@@ -49,11 +49,11 @@ function Comp(p: Prop) {
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     return <div>{p.b}</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 >p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
 >p : Symbol(p, Decl(file.tsx, 18, 14))
 >b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 // Ok
diff --git a/tests/baselines/reference/checkJsxChildrenProperty8.symbols b/tests/baselines/reference/checkJsxChildrenProperty8.symbols
index b6f5f97adac..3d2e232203b 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty8.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty8.symbols
@@ -13,24 +13,24 @@ interface Prop {
 
     children: string | JSX.Element | (string | JSX.Element)[];
 >children : Symbol(Prop.children, Decl(file.tsx, 4, 14))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 }
 
 class Button extends React.Component<any, any> {
 >Button : Symbol(Button, Decl(file.tsx, 6, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(Button.render, Decl(file.tsx, 8, 48))
 
         return (<div>My Button</div>)
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
@@ -39,8 +39,8 @@ function AnotherButton(p: any) {
 >p : Symbol(p, Decl(file.tsx, 14, 23))
 
     return <h1>Just Another Button</h1>;
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 }
 
 function Comp(p: Prop) {
@@ -49,11 +49,11 @@ function Comp(p: Prop) {
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     return <div>{p.b}</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 >p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
 >p : Symbol(p, Decl(file.tsx, 18, 14))
 >b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 // OK
diff --git a/tests/baselines/reference/checkJsxChildrenProperty9.symbols b/tests/baselines/reference/checkJsxChildrenProperty9.symbols
index 25a32aae695..147fc4939f5 100644
--- a/tests/baselines/reference/checkJsxChildrenProperty9.symbols
+++ b/tests/baselines/reference/checkJsxChildrenProperty9.symbols
@@ -5,26 +5,26 @@ import React = require('react');
 // OK
 let k1 = <div> <h2> Hello </h2> <h1> world </h1></div>;
 >k1 : Symbol(k1, Decl(file.tsx, 3, 3))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 let k2 = <div> <h2> Hello </h2> {(user: any) => <h2>{user.name}</h2>}</div>;
 >k2 : Symbol(k2, Decl(file.tsx, 4, 3))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
 >user : Symbol(user, Decl(file.tsx, 4, 34))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
 >user : Symbol(user, Decl(file.tsx, 4, 34))
->h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2410, 48))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>h2 : Symbol(JSX.IntrinsicElements.h2, Decl(react.d.ts, 2411, 48))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 let k3 = <div> {1} {"That is a number"} </div>;
 >k3 : Symbol(k3, Decl(file.tsx, 5, 3))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
diff --git a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.symbols b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.symbols
index 33f8f88f9e0..2a6ba238b4b 100644
--- a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.symbols
+++ b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.symbols
@@ -12,9 +12,9 @@ class A {
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         x.forEach((v) => {
->x.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>x.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 3, 9))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 4, 19))
 
             switch(v) {
diff --git a/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types b/tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types
index 115930df20a..30f584894fc 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: 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.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >x : 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; }
->(v) => {            switch(v) {                case "test": use(this);            }        } : (this: void, v: string) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>(v) => {            switch(v) {                case "test": use(this);            }        } : (v: string) => void
 >v : string
 
             switch(v) {
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
index cd7cbdba7bd..2cf04ac05d3 100644
--- a/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticProperties3.symbols
@@ -30,9 +30,9 @@ for (let i = 0; i < 3; i++) {
     });
 }
 arr.forEach(C => console.log(C.y()));
->arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>arr.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticProperties3.ts, 1, 5))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >C : Symbol(C, Decl(classExpressionWithStaticProperties3.ts, 8, 12))
 >console : Symbol(console, Decl(classExpressionWithStaticProperties3.ts, 0, 11))
 >C.y : Symbol(y, Decl(classExpressionWithStaticProperties3.ts, 1, 12))
diff --git a/tests/baselines/reference/classExpressionWithStaticProperties3.types b/tests/baselines/reference/classExpressionWithStaticProperties3.types
index 6f598e6e42e..67823ea8340 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: 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.forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >arr : { y(): number; }[]
->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
+>forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>C => console.log(C.y()) : (C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
 >console.log : any
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
index 822dfaf81a0..d39463b228c 100644
--- a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
+++ b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.symbols
@@ -30,9 +30,9 @@ for (let i = 0; i < 3; i++) {
     });
 }
 arr.forEach(C => console.log(C.y()));
->arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>arr.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >arr : Symbol(arr, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 5))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >C : Symbol(C, Decl(classExpressionWithStaticPropertiesES63.ts, 8, 12))
 >console : Symbol(console, Decl(classExpressionWithStaticPropertiesES63.ts, 0, 11))
 >C.y : Symbol(y, Decl(classExpressionWithStaticPropertiesES63.ts, 1, 12))
diff --git a/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types b/tests/baselines/reference/classExpressionWithStaticPropertiesES63.types
index b5cd81e8590..5a948f54402 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: 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.forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >arr : { y(): number; }[]
->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
+>forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>C => console.log(C.y()) : (C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
 >console.log : any
diff --git a/tests/baselines/reference/commaOperatorInConditionalExpression.symbols b/tests/baselines/reference/commaOperatorInConditionalExpression.symbols
index cb124f21f15..c5734cbbc9b 100644
--- a/tests/baselines/reference/commaOperatorInConditionalExpression.symbols
+++ b/tests/baselines/reference/commaOperatorInConditionalExpression.symbols
@@ -4,8 +4,8 @@ function f (m: string) {
 >m : Symbol(m, Decl(commaOperatorInConditionalExpression.ts, 0, 12))
 
     [1, 2, 3].map(i => {
->[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(commaOperatorInConditionalExpression.ts, 1, 18))
 
         return true? { [m]: i } : { [m]: i + 1 }
diff --git a/tests/baselines/reference/commaOperatorInConditionalExpression.types b/tests/baselines/reference/commaOperatorInConditionalExpression.types
index 7ee2ab72c77..1d1037c1206 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: 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].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 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[]; }
->i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (this: void, i: number) => { [x: string]: number; }
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (i: number) => { [x: string]: number; }
 >i : number
 
         return true? { [m]: i } : { [m]: i + 1 }
diff --git a/tests/baselines/reference/commentEmittingInPreserveJsx1.symbols b/tests/baselines/reference/commentEmittingInPreserveJsx1.symbols
index 43d833e27b1..9accc8af0b6 100644
--- a/tests/baselines/reference/commentEmittingInPreserveJsx1.symbols
+++ b/tests/baselines/reference/commentEmittingInPreserveJsx1.symbols
@@ -3,14 +3,14 @@ import React = require('react');
 >React : Symbol(React, Decl(file.tsx, 0, 0))
 
 <div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     // Not Comment
 </div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 <div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     // Not Comment
     {
@@ -18,10 +18,10 @@ import React = require('react');
     }
     // Another not Comment
 </div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 <div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     // Not Comment
     {
@@ -30,10 +30,10 @@ import React = require('react');
     }
     // Another not Comment
 </div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 <div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     /* Not Comment */
     {
@@ -41,5 +41,5 @@ import React = require('react');
         "Hi"
     }
 </div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
diff --git a/tests/baselines/reference/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols
index e082d24daf3..9db0719cf89 100644
--- a/tests/baselines/reference/commentInMethodCall.symbols
+++ b/tests/baselines/reference/commentInMethodCall.symbols
@@ -4,9 +4,9 @@ var s: string[];
 >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3))
 
 s.map(// do something
->s.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>s.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 
     function () { });
 
diff --git a/tests/baselines/reference/commentInMethodCall.types b/tests/baselines/reference/commentInMethodCall.types
index b74323d1477..e9543a8c6f2 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: 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.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s : 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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 
     function () { });
->function () { } : (this: void) => void
+>function () { } : () => void
 
diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.symbols b/tests/baselines/reference/contextualSignatureInstantiation3.symbols
index a9653673ff2..6d480a7aef4 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation3.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation3.symbols
@@ -12,9 +12,9 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
 >U : Symbol(U, Decl(contextualSignatureInstantiation3.ts, 0, 15))
 
     return items.map(f);
->items.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>items.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >items : Symbol(items, Decl(contextualSignatureInstantiation3.ts, 0, 19))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(contextualSignatureInstantiation3.ts, 0, 30))
 }
 
@@ -47,9 +47,9 @@ var v1: number[];
 
 var v1 = xs.map(identity);      // Error if not number[]
 >v1 : Symbol(v1, Decl(contextualSignatureInstantiation3.ts, 15, 3), Decl(contextualSignatureInstantiation3.ts, 16, 3), Decl(contextualSignatureInstantiation3.ts, 17, 3))
->xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >identity : Symbol(identity, Decl(contextualSignatureInstantiation3.ts, 2, 1))
 
 var v1 = map(xs, identity);     // Error if not number[]
@@ -63,9 +63,9 @@ var v2: number[][];
 
 var v2 = xs.map(singleton);     // Error if not number[][]
 >v2 : Symbol(v2, Decl(contextualSignatureInstantiation3.ts, 19, 3), Decl(contextualSignatureInstantiation3.ts, 20, 3), Decl(contextualSignatureInstantiation3.ts, 21, 3))
->xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >singleton : Symbol(singleton, Decl(contextualSignatureInstantiation3.ts, 6, 1))
 
 var v2 = map(xs, singleton);    // Error if not number[][]
diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.types b/tests/baselines/reference/contextualSignatureInstantiation3.types
index 60ad7c31bf6..945a4374ad1 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: 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.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >items : T[]
->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[]; }
+>map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => 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: 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.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : 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[]; }
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => 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: 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.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : 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[]; }
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >singleton : <T>(x: T) => T[]
 
 var v2 = map(xs, singleton);    // Error if not number[][]
diff --git a/tests/baselines/reference/contextuallyTypedIife.symbols b/tests/baselines/reference/contextuallyTypedIife.symbols
index 96e57c1f62f..b6a73764352 100644
--- a/tests/baselines/reference/contextuallyTypedIife.symbols
+++ b/tests/baselines/reference/contextuallyTypedIife.symbols
@@ -47,25 +47,25 @@
 // rest parameters
 ((...numbers) => numbers.every(n => n > 0))(5,6,7);
 >numbers : Symbol(numbers, Decl(contextuallyTypedIife.ts, 17, 2))
->numbers.every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numbers.every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >numbers : Symbol(numbers, Decl(contextuallyTypedIife.ts, 17, 2))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 17, 31))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 17, 31))
 
 ((...mixed) => mixed.every(n => !!n))(5,'oops','oh no');
 >mixed : Symbol(mixed, Decl(contextuallyTypedIife.ts, 18, 2))
->mixed.every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>mixed.every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >mixed : Symbol(mixed, Decl(contextuallyTypedIife.ts, 18, 2))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 18, 27))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 18, 27))
 
 ((...noNumbers) => noNumbers.some(n => n > 0))();
 >noNumbers : Symbol(noNumbers, Decl(contextuallyTypedIife.ts, 19, 2))
->noNumbers.some : Symbol(Array.some, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>noNumbers.some : Symbol(Array.some, Decl(lib.d.ts, --, --))
 >noNumbers : Symbol(noNumbers, Decl(contextuallyTypedIife.ts, 19, 2))
->some : Symbol(Array.some, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 19, 34))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 19, 34))
 
@@ -73,9 +73,9 @@
 >first : Symbol(first, Decl(contextuallyTypedIife.ts, 20, 2))
 >rest : Symbol(rest, Decl(contextuallyTypedIife.ts, 20, 8))
 >first : Symbol(first, Decl(contextuallyTypedIife.ts, 20, 2))
->rest.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>rest.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >rest : Symbol(rest, Decl(contextuallyTypedIife.ts, 20, 8))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 20, 43))
 >n : Symbol(n, Decl(contextuallyTypedIife.ts, 20, 43))
 
diff --git a/tests/baselines/reference/contextuallyTypedIife.types b/tests/baselines/reference/contextuallyTypedIife.types
index 77bb40df903..7b86fe1f337 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: 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.every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >numbers : number[]
->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
+>every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>n => n > 0 : (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: 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.every : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
 >mixed : (string | number)[]
->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
+>every : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
+>n => !!n : (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: 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.some : (callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
 >noNumbers : any[]
->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
+>some : (callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
+>n => n > 0 : (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: 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.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >rest : 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 > 0 : (this: void, n: number) => boolean
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n > 0 : (n: number) => boolean
 >n : number
 >n > 0 : boolean
 >n : number
diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.symbols b/tests/baselines/reference/controlFlowDestructuringParameters.symbols
index 1874c16c3d3..668d346b929 100644
--- a/tests/baselines/reference/controlFlowDestructuringParameters.symbols
+++ b/tests/baselines/reference/controlFlowDestructuringParameters.symbols
@@ -3,9 +3,9 @@
 
 
 [{ x: 1 }].map(
->[{ x: 1 }].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[{ x: 1 }].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(controlFlowDestructuringParameters.ts, 3, 2))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 
   ({ x }) => x
 >x : Symbol(x, Decl(controlFlowDestructuringParameters.ts, 4, 4))
diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.types b/tests/baselines/reference/controlFlowDestructuringParameters.types
index 44755dca81b..9c6c96de540 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: 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 }].map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => 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: 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[]; }
+>map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
 
   ({ x }) => x
->({ x }) => x : (this: void, { x }: { x: number; }) => number
+>({ x }) => x : ({ x }: { x: number; }) => number
 >x : number
 >x : number
 
diff --git a/tests/baselines/reference/controlFlowInstanceof.types b/tests/baselines/reference/controlFlowInstanceof.types
index 16d1ec71462..5b9ea793e7d 100644
--- a/tests/baselines/reference/controlFlowInstanceof.types
+++ b/tests/baselines/reference/controlFlowInstanceof.types
@@ -247,7 +247,7 @@ function goo(x: X) {
 
         x.y;
 >x.y : string
->x : Y
+>x : X & Y
 >y : string
     }
     x;
diff --git a/tests/baselines/reference/correctlyMarkAliasAsReferences1.symbols b/tests/baselines/reference/correctlyMarkAliasAsReferences1.symbols
index 3267a29050e..b0338f1c803 100644
--- a/tests/baselines/reference/correctlyMarkAliasAsReferences1.symbols
+++ b/tests/baselines/reference/correctlyMarkAliasAsReferences1.symbols
@@ -11,17 +11,17 @@ let buttonProps; // any
 
 let k = <button {...buttonProps}>
 >k : Symbol(k, Decl(0.tsx, 5, 3))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 >buttonProps : Symbol(buttonProps, Decl(0.tsx, 4, 3))
 
             <span className={cx('class1', { class2: true })} />
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 >className : Symbol(className, Decl(0.tsx, 6, 17))
 >cx : Symbol(cx, Decl(0.tsx, 1, 6))
 >class2 : Symbol(class2, Decl(0.tsx, 6, 43))
 
         </button>;
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 
 === tests/cases/conformance/jsx/declaration.d.ts ===
 declare module "classnames";
diff --git a/tests/baselines/reference/correctlyMarkAliasAsReferences2.symbols b/tests/baselines/reference/correctlyMarkAliasAsReferences2.symbols
index 76d9b8cdfe0..7e131bde878 100644
--- a/tests/baselines/reference/correctlyMarkAliasAsReferences2.symbols
+++ b/tests/baselines/reference/correctlyMarkAliasAsReferences2.symbols
@@ -12,17 +12,17 @@ let buttonProps : {[attributeName: string]: ''}
 
 let k = <button {...buttonProps}>
 >k : Symbol(k, Decl(0.tsx, 5, 3))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 >buttonProps : Symbol(buttonProps, Decl(0.tsx, 4, 3))
 
             <span className={cx('class1', { class2: true })} />
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 >className : Symbol(className, Decl(0.tsx, 6, 17))
 >cx : Symbol(cx, Decl(0.tsx, 1, 6))
 >class2 : Symbol(class2, Decl(0.tsx, 6, 43))
 
         </button>;
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 
 === tests/cases/conformance/jsx/declaration.d.ts ===
 declare module "classnames";
diff --git a/tests/baselines/reference/correctlyMarkAliasAsReferences3.symbols b/tests/baselines/reference/correctlyMarkAliasAsReferences3.symbols
index 088f553baa4..4002c29b3c6 100644
--- a/tests/baselines/reference/correctlyMarkAliasAsReferences3.symbols
+++ b/tests/baselines/reference/correctlyMarkAliasAsReferences3.symbols
@@ -11,17 +11,17 @@ let buttonProps;
 
 let k = <button {...buttonProps}>
 >k : Symbol(k, Decl(0.tsx, 5, 3))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 >buttonProps : Symbol(buttonProps, Decl(0.tsx, 4, 3))
 
             <span className={cx('class1', { class2: true })} />
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 >className : Symbol(className, Decl(0.tsx, 6, 17))
 >cx : Symbol(cx, Decl(0.tsx, 1, 6))
 >class2 : Symbol(class2, Decl(0.tsx, 6, 43))
 
         </button>;
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 
 === tests/cases/conformance/jsx/declaration.d.ts ===
 declare module "classnames";
diff --git a/tests/baselines/reference/correctlyMarkAliasAsReferences4.symbols b/tests/baselines/reference/correctlyMarkAliasAsReferences4.symbols
index 83b245072e9..0253e34533f 100644
--- a/tests/baselines/reference/correctlyMarkAliasAsReferences4.symbols
+++ b/tests/baselines/reference/correctlyMarkAliasAsReferences4.symbols
@@ -12,7 +12,7 @@ let buttonProps : {[attributeName: string]: ''}
 
 let k = <button {...buttonProps} className={cx('class1', { class2: true })} />;
 >k : Symbol(k, Decl(0.tsx, 5, 3))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 >buttonProps : Symbol(buttonProps, Decl(0.tsx, 4, 3))
 >className : Symbol(className, Decl(0.tsx, 5, 32))
 >cx : Symbol(cx, Decl(0.tsx, 1, 6))
diff --git a/tests/baselines/reference/declarationEmitPromise.symbols b/tests/baselines/reference/declarationEmitPromise.symbols
index d1333bb060c..2e9185d2e39 100644
--- a/tests/baselines/reference/declarationEmitPromise.symbols
+++ b/tests/baselines/reference/declarationEmitPromise.symbols
@@ -39,13 +39,13 @@ export async function runSampleWorks<A, B, C, D, E>(
 >bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
 >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0))
 >all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
->[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >a : Symbol(a, Decl(declarationEmitPromise.ts, 4, 52))
 >b : Symbol(b, Decl(declarationEmitPromise.ts, 5, 19))
 >c : Symbol(c, Decl(declarationEmitPromise.ts, 5, 36))
 >d : Symbol(d, Decl(declarationEmitPromise.ts, 5, 53))
 >e : Symbol(e, Decl(declarationEmitPromise.ts, 5, 70))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 6, 68))
 
@@ -111,13 +111,13 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >bluebird.all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
 >bluebird : Symbol(bluebird, Decl(declarationEmitPromise.ts, 0, 0))
 >all : Symbol(bluebird.all, Decl(declarationEmitPromise.ts, 0, 26))
->[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>[a, b, c, d, e].filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >a : Symbol(a, Decl(declarationEmitPromise.ts, 13, 53))
 >b : Symbol(b, Decl(declarationEmitPromise.ts, 14, 19))
 >c : Symbol(c, Decl(declarationEmitPromise.ts, 14, 36))
 >d : Symbol(d, Decl(declarationEmitPromise.ts, 14, 53))
 >e : Symbol(e, Decl(declarationEmitPromise.ts, 14, 70))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68))
 >el : Symbol(el, Decl(declarationEmitPromise.ts, 15, 68))
 
diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types
index 9fafbd0cbd6..d3fc75c63ad 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: 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].filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): 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: 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
+>filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>el => !!el : (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: 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].filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): 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: 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
+>filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>el => !!el : (el: bluebird<A>) => boolean
 >el : bluebird<A>
 >!!el : boolean
 >!el : boolean
diff --git a/tests/baselines/reference/emitter.forAwait.es2017.js b/tests/baselines/reference/emitter.forAwait.es2017.js
new file mode 100644
index 00000000000..eb953781ab3
--- /dev/null
+++ b/tests/baselines/reference/emitter.forAwait.es2017.js
@@ -0,0 +1,143 @@
+//// [tests/cases/conformance/emitter/es2017/forAwait/emitter.forAwait.es2017.ts] ////
+
+//// [file1.ts]
+async function f1() {
+    let y: any;
+    for await (const x of y) {
+    }
+}
+//// [file2.ts]
+async function f2() {
+    let x: any, y: any;
+    for await (x of y) {
+    }
+}
+//// [file3.ts]
+async function* f3() {
+    let y: any;
+    for await (const x of y) {
+    }
+}
+//// [file4.ts]
+async function* f4() {
+    let x: any, y: any;
+    for await (x of y) {
+    }
+}
+
+//// [file1.js]
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+async function f1() {
+    let y;
+    try {
+        for (var y_1 = __asyncValues(y), y_1_1; y_1_1 = await y_1.next(), !y_1_1.done;) {
+            const x = await y_1_1.value;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (y_1_1 && !y_1_1.done && (_a = y_1.return)) await _a.call(y_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var e_1, _a;
+}
+//// [file2.js]
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+async function f2() {
+    let x, y;
+    try {
+        for (var y_1 = __asyncValues(y), y_1_1; y_1_1 = await y_1.next(), !y_1_1.done;) {
+            x = await y_1_1.value;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (y_1_1 && !y_1_1.done && (_a = y_1.return)) await _a.call(y_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var e_1, _a;
+}
+//// [file3.js]
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+function f3() {
+    return __asyncGenerator(this, arguments, function* f3_1() {
+        let y;
+        try {
+            for (var y_1 = __asyncValues(y), y_1_1; y_1_1 = yield __await(y_1.next()), !y_1_1.done;) {
+                const x = yield __await(y_1_1.value);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield __await(_a.call(y_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _a;
+    });
+}
+//// [file4.js]
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+function f4() {
+    return __asyncGenerator(this, arguments, function* f4_1() {
+        let x, y;
+        try {
+            for (var y_1 = __asyncValues(y), y_1_1; y_1_1 = yield __await(y_1.next()), !y_1_1.done;) {
+                x = yield __await(y_1_1.value);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (y_1_1 && !y_1_1.done && (_a = y_1.return)) yield __await(_a.call(y_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _a;
+    });
+}
diff --git a/tests/baselines/reference/emitter.forAwait.es2017.symbols b/tests/baselines/reference/emitter.forAwait.es2017.symbols
new file mode 100644
index 00000000000..a08e31f5553
--- /dev/null
+++ b/tests/baselines/reference/emitter.forAwait.es2017.symbols
@@ -0,0 +1,50 @@
+=== tests/cases/conformance/emitter/es2017/forAwait/file1.ts ===
+async function f1() {
+>f1 : Symbol(f1, Decl(file1.ts, 0, 0))
+
+    let y: any;
+>y : Symbol(y, Decl(file1.ts, 1, 7))
+
+    for await (const x of y) {
+>x : Symbol(x, Decl(file1.ts, 2, 20))
+>y : Symbol(y, Decl(file1.ts, 1, 7))
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file2.ts ===
+async function f2() {
+>f2 : Symbol(f2, Decl(file2.ts, 0, 0))
+
+    let x: any, y: any;
+>x : Symbol(x, Decl(file2.ts, 1, 7))
+>y : Symbol(y, Decl(file2.ts, 1, 15))
+
+    for await (x of y) {
+>x : Symbol(x, Decl(file2.ts, 1, 7))
+>y : Symbol(y, Decl(file2.ts, 1, 15))
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file3.ts ===
+async function* f3() {
+>f3 : Symbol(f3, Decl(file3.ts, 0, 0))
+
+    let y: any;
+>y : Symbol(y, Decl(file3.ts, 1, 7))
+
+    for await (const x of y) {
+>x : Symbol(x, Decl(file3.ts, 2, 20))
+>y : Symbol(y, Decl(file3.ts, 1, 7))
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file4.ts ===
+async function* f4() {
+>f4 : Symbol(f4, Decl(file4.ts, 0, 0))
+
+    let x: any, y: any;
+>x : Symbol(x, Decl(file4.ts, 1, 7))
+>y : Symbol(y, Decl(file4.ts, 1, 15))
+
+    for await (x of y) {
+>x : Symbol(x, Decl(file4.ts, 1, 7))
+>y : Symbol(y, Decl(file4.ts, 1, 15))
+    }
+}
diff --git a/tests/baselines/reference/emitter.forAwait.es2017.types b/tests/baselines/reference/emitter.forAwait.es2017.types
new file mode 100644
index 00000000000..0d886cca4cc
--- /dev/null
+++ b/tests/baselines/reference/emitter.forAwait.es2017.types
@@ -0,0 +1,50 @@
+=== tests/cases/conformance/emitter/es2017/forAwait/file1.ts ===
+async function f1() {
+>f1 : () => Promise<void>
+
+    let y: any;
+>y : any
+
+    for await (const x of y) {
+>x : any
+>y : any
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file2.ts ===
+async function f2() {
+>f2 : () => Promise<void>
+
+    let x: any, y: any;
+>x : any
+>y : any
+
+    for await (x of y) {
+>x : any
+>y : any
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file3.ts ===
+async function* f3() {
+>f3 : () => AsyncIterableIterator<any>
+
+    let y: any;
+>y : any
+
+    for await (const x of y) {
+>x : any
+>y : any
+    }
+}
+=== tests/cases/conformance/emitter/es2017/forAwait/file4.ts ===
+async function* f4() {
+>f4 : () => AsyncIterableIterator<any>
+
+    let x: any, y: any;
+>x : any
+>y : any
+
+    for await (x of y) {
+>x : any
+>y : any
+    }
+}
diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols
index cf87cb106d1..59191a73276 100644
--- a/tests/baselines/reference/enumIndexer.symbols
+++ b/tests/baselines/reference/enumIndexer.symbols
@@ -19,9 +19,9 @@ var enumValue = MyEnumType.foo;
 
 var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type
 >x : Symbol(x, Decl(enumIndexer.ts, 5, 3))
->_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >o : Symbol(o, Decl(enumIndexer.ts, 5, 17))
 >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0))
 >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types
index eb4b4e18e76..6c6e50822b5 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: 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.map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
 >_arr : { key: string; }[]
->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
+>map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
+>o => MyEnumType[o.key] === enumValue : (o: { key: string; }) => boolean
 >o : { key: string; }
 >MyEnumType[o.key] === enumValue : boolean
 >MyEnumType[o.key] : any
diff --git a/tests/baselines/reference/exactSpellingSuggestion.errors.txt b/tests/baselines/reference/exactSpellingSuggestion.errors.txt
new file mode 100644
index 00000000000..dbe611590d4
--- /dev/null
+++ b/tests/baselines/reference/exactSpellingSuggestion.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/compiler/exactSpellingSuggestion.ts(9,4): error TS2551: Property 'bit_2' does not exist on type 'typeof U8'. Did you mean 'BIT_2'?
+
+
+==== tests/cases/compiler/exactSpellingSuggestion.ts (1 errors) ====
+    // Fixes #16245 -- always suggest the exact match, even when
+    // other options are very close
+    enum U8 {
+        BIT_0 = 1 << 0,
+        BIT_1 = 1 << 1,
+        BIT_2 = 1 << 2
+    }
+    
+    U8.bit_2
+       ~~~~~
+!!! error TS2551: Property 'bit_2' does not exist on type 'typeof U8'. Did you mean 'BIT_2'?
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/exactSpellingSuggestion.js b/tests/baselines/reference/exactSpellingSuggestion.js
new file mode 100644
index 00000000000..7b71065061d
--- /dev/null
+++ b/tests/baselines/reference/exactSpellingSuggestion.js
@@ -0,0 +1,22 @@
+//// [exactSpellingSuggestion.ts]
+// Fixes #16245 -- always suggest the exact match, even when
+// other options are very close
+enum U8 {
+    BIT_0 = 1 << 0,
+    BIT_1 = 1 << 1,
+    BIT_2 = 1 << 2
+}
+
+U8.bit_2
+
+
+//// [exactSpellingSuggestion.js]
+// Fixes #16245 -- always suggest the exact match, even when
+// other options are very close
+var U8;
+(function (U8) {
+    U8[U8["BIT_0"] = 1] = "BIT_0";
+    U8[U8["BIT_1"] = 2] = "BIT_1";
+    U8[U8["BIT_2"] = 4] = "BIT_2";
+})(U8 || (U8 = {}));
+U8.bit_2;
diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols
index f548f34e553..b73872b8d55 100644
--- a/tests/baselines/reference/genericArray1.symbols
+++ b/tests/baselines/reference/genericArray1.symbols
@@ -13,8 +13,8 @@ interface String{
 
 var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3))
->["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
 >x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
diff --git a/tests/baselines/reference/genericArray1.types b/tests/baselines/reference/genericArray1.types
index bf5d55eb569..baa2ec8a9cf 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: 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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b", "c"] : string[]
 >"a" : "a"
 >"b" : "b"
 >"c" : "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[]; }
->x => x.length : (this: void, x: string) => number
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>x => x.length : (x: string) => number
 >x : string
 >x.length : number
 >x : string
diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols
index ecc9c811d76..8beecf27254 100644
--- a/tests/baselines/reference/genericInference1.symbols
+++ b/tests/baselines/reference/genericInference1.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/genericInference1.ts ===
 ['a', 'b', 'c'].map(x => x.length);
->['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
 >x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
diff --git a/tests/baselines/reference/genericInference1.types b/tests/baselines/reference/genericInference1.types
index 8995e07c825..30b7279ebc0 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: 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'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >['a', 'b', 'c'] : string[]
 >'a' : "a"
 >'b' : "b"
 >'c' : "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[]; }
->x => x.length : (this: void, x: string) => number
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>x => x.length : (x: string) => number
 >x : string
 >x.length : number
 >x : string
diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols
index 55ff9cb5afb..9cf7bb995b1 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.symbols
+++ b/tests/baselines/reference/genericMethodOverspecialization.symbols
@@ -27,9 +27,9 @@ interface Document {
 
 var elements = names.map(function (name) {
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->names.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>names.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35))
 
     return document.getElementById(name);
@@ -43,9 +43,9 @@ var elements = names.map(function (name) {
 
 var xxx = elements.filter(function (e) {
 >xxx : Symbol(xxx, Decl(genericMethodOverspecialization.ts, 17, 3))
->elements.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>elements.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36))
 
     return !e.isDisabled;
@@ -57,9 +57,9 @@ var xxx = elements.filter(function (e) {
 
 var widths:number[] = elements.map(function (e) { // should not error
 >widths : Symbol(widths, Decl(genericMethodOverspecialization.ts, 21, 3))
->elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45))
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericMethodOverspecialization.types b/tests/baselines/reference/genericMethodOverspecialization.types
index 17f3e0dddd7..40286124f51 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: 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.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >names : 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 (name) {    return document.getElementById(name);} : (this: void, name: string) => HTMLElement
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>function (name) {    return document.getElementById(name);} : (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: 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.filter : { <S extends HTMLElement>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
 >elements : HTMLElement[]
->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
+>filter : { <S extends HTMLElement>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
+>function (e) {    return !e.isDisabled;} : (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: 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.map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
 >elements : HTMLElement[]
->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
+>map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
+>function (e) { // should not error    return e.clientWidth;} : (e: HTMLElement) => number
 >e : HTMLElement
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/implementArrayInterface.errors.txt b/tests/baselines/reference/implementArrayInterface.errors.txt
deleted file mode 100644
index 61c4440fa3a..00000000000
--- a/tests/baselines/reference/implementArrayInterface.errors.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-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: 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[]'.
-
-
-==== tests/cases/compiler/implementArrayInterface.ts (1 errors) ====
-    declare class MyArray<T> implements Array<T> {
-                  ~~~~~~~
-!!! 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: 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;
-        toLocaleString(): string;
-        concat<U extends T[]>(...items: U[]): T[];
-        concat(...items: T[]): T[];
-        join(separator?: string): string;
-        pop(): T;
-        push(...items: T[]): number;
-        reverse(): T[];
-        shift(): T;
-        slice(start?: number, end?: number): T[];
-        sort(compareFn?: (a: T, b: T) => number): this;
-        splice(start: number): T[];
-        splice(start: number, deleteCount: number, ...items: T[]): T[];
-        unshift(...items: T[]): number;
-    
-        indexOf(searchElement: T, fromIndex?: number): number;
-        lastIndexOf(searchElement: T, fromIndex?: number): number;
-        every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
-        some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
-        forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
-        map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
-        filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
-        reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
-        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-        reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
-        reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    
-        length: number;
-    
-        [n: number]: T;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpression1ESNext.js b/tests/baselines/reference/importCallExpression1ESNext.js
new file mode 100644
index 00000000000..39b779c921f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression1ESNext.js
@@ -0,0 +1,27 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression1ESNext.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+})
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+export function foo() { return "foo"; }
+//// [1.js]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+function foo() {
+    const p2 = import("./0");
+}
diff --git a/tests/baselines/reference/importCallExpression1ESNext.symbols b/tests/baselines/reference/importCallExpression1ESNext.symbols
new file mode 100644
index 00000000000..28b5ba13e99
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression1ESNext.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+})
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 2))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpression1ESNext.types b/tests/baselines/reference/importCallExpression1ESNext.types
new file mode 100644
index 00000000000..53a1b3d08fa
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression1ESNext.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+})
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpression2ESNext.js b/tests/baselines/reference/importCallExpression2ESNext.js
new file mode 100644
index 00000000000..662f57f07ff
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression2ESNext.js
@@ -0,0 +1,29 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression2ESNext.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
+
+//// [0.js]
+export class B {
+    print() { return "I am B"; }
+}
+//// [2.js]
+function foo(x) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    });
+}
+foo(import("./0"));
diff --git a/tests/baselines/reference/importCallExpression2ESNext.symbols b/tests/baselines/reference/importCallExpression2ESNext.symbols
new file mode 100644
index 00000000000..2002398aeb9
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression2ESNext.symbols
@@ -0,0 +1,33 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+function foo(x: Promise<any>) {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+>x : Symbol(x, Decl(2.ts, 0, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    x.then(value => {
+>x.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(2.ts, 0, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>value : Symbol(value, Decl(2.ts, 1, 11))
+
+        let b = new value.B();
+>b : Symbol(b, Decl(2.ts, 2, 11))
+>value : Symbol(value, Decl(2.ts, 1, 11))
+
+        b.print();
+>b : Symbol(b, Decl(2.ts, 2, 11))
+
+    })
+}
+
+foo(import("./0"));
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpression2ESNext.types b/tests/baselines/reference/importCallExpression2ESNext.types
new file mode 100644
index 00000000000..084eb33dde9
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression2ESNext.types
@@ -0,0 +1,45 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+function foo(x: Promise<any>) {
+>foo : (x: Promise<any>) => void
+>x : Promise<any>
+>Promise : Promise<T>
+
+    x.then(value => {
+>x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>value => {        let b = new value.B();        b.print();    } : (value: any) => void
+>value : any
+
+        let b = new value.B();
+>b : any
+>new value.B() : any
+>value.B : any
+>value : any
+>B : any
+
+        b.print();
+>b.print() : any
+>b.print : any
+>b : any
+>print : any
+
+    })
+}
+
+foo(import("./0"));
+>foo(import("./0")) : void
+>foo : (x: Promise<any>) => void
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpression3ESNext.js b/tests/baselines/reference/importCallExpression3ESNext.js
new file mode 100644
index 00000000000..0cd41388616
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression3ESNext.js
@@ -0,0 +1,27 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression3ESNext.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
+
+//// [0.js]
+export class B {
+    print() { return "I am B"; }
+}
+//// [2.js]
+async function foo() {
+    class C extends (await import("./0")).B {
+    }
+    var c = new C();
+    c.print();
+}
+foo();
diff --git a/tests/baselines/reference/importCallExpression3ESNext.symbols b/tests/baselines/reference/importCallExpression3ESNext.symbols
new file mode 100644
index 00000000000..5ca85d6e693
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression3ESNext.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
+    class C extends (await import("./0")).B {}
+>C : Symbol(C, Decl(2.ts, 0, 22))
+>(await import("./0")).B : Symbol(B, Decl(0.ts, 0, 0))
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    var c = new C();
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>C : Symbol(C, Decl(2.ts, 0, 22))
+
+    c.print();
+>c.print : Symbol(B.print, Decl(0.ts, 0, 16))
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+foo();
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpression3ESNext.types b/tests/baselines/reference/importCallExpression3ESNext.types
new file mode 100644
index 00000000000..e517be6e722
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression3ESNext.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : () => Promise<void>
+
+    class C extends (await import("./0")).B {}
+>C : C
+>(await import("./0")).B : B
+>(await import("./0")) : typeof "tests/cases/conformance/dynamicImport/0"
+>await import("./0") : typeof "tests/cases/conformance/dynamicImport/0"
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+>B : typeof B
+
+    var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+    c.print();
+>c.print() : string
+>c.print : () => string
+>c : C
+>print : () => string
+}
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/baselines/reference/importCallExpression4ESNext.js b/tests/baselines/reference/importCallExpression4ESNext.js
new file mode 100644
index 00000000000..e148d5c1e51
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression4ESNext.js
@@ -0,0 +1,49 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
+
+//// [0.js]
+export class B {
+    print() { return "I am B"; }
+}
+export function foo() { return "foo"; }
+//// [1.js]
+export function backup() { return "backup"; }
+//// [2.js]
+class C {
+    constructor() {
+        this.myModule = import("./0");
+    }
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async (err) => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpression4ESNext.symbols b/tests/baselines/reference/importCallExpression4ESNext.symbols
new file mode 100644
index 00000000000..34a1dcf4d7b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression4ESNext.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+export function foo() { return "foo" }
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : Symbol(console, Decl(2.ts, 0, 11))
+
+class C {
+>C : Symbol(C, Decl(2.ts, 0, 25))
+
+    private myModule = import("./0");
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+
+    method() {
+>method : Symbol(C.method, Decl(2.ts, 2, 37))
+
+        this.myModule.then(Zero => {
+>this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this : Symbol(C, Decl(2.ts, 0, 25))
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+
+            console.log(Zero.foo());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+        }, async err => {
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            console.log(err);
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            let one = await import("./1");
+>one : Symbol(one, Decl(2.ts, 8, 15))
+
+            console.log(one.backup());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>one.backup : Symbol(backup, Decl(1.ts, 0, 0))
+>one : Symbol(one, Decl(2.ts, 8, 15))
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpression4ESNext.types b/tests/baselines/reference/importCallExpression4ESNext.types
new file mode 100644
index 00000000000..2ea666ba672
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression4ESNext.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+export function foo() { return "foo" }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : any
+
+class C {
+>C : C
+
+    private myModule = import("./0");
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+    method() {
+>method : () => void
+
+        this.myModule.then(Zero => {
+>this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>this : this
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+            console.log(Zero.foo());
+>console.log(Zero.foo()) : any
+>console.log : any
+>console : any
+>log : any
+>Zero.foo() : string
+>Zero.foo : () => string
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+        }, async err => {
+>async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        } : (err: any) => Promise<void>
+>err : any
+
+            console.log(err);
+>console.log(err) : any
+>console.log : any
+>console : any
+>log : any
+>err : any
+
+            let one = await import("./1");
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+            console.log(one.backup());
+>console.log(one.backup()) : any
+>console.log : any
+>console : any
+>log : any
+>one.backup() : string
+>one.backup : () => string
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>backup : () => string
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpression5ESNext.errors.txt b/tests/baselines/reference/importCallExpression5ESNext.errors.txt
new file mode 100644
index 00000000000..ed5900c2a03
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression5ESNext.errors.txt
@@ -0,0 +1,31 @@
+tests/cases/conformance/dynamicImport/2.ts(3,23): error TS7036: Dynamic import's specifier must be of type 'string', but here has type '"./0" | undefined'.
+tests/cases/conformance/dynamicImport/2.ts(4,24): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+tests/cases/conformance/dynamicImport/2.ts(5,24): error TS7036: Dynamic import's specifier must be of type 'string', but here has type '"./1" | null'.
+tests/cases/conformance/dynamicImport/2.ts(6,24): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'null'.
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export class B {
+        print() { return "I am B"}
+    }
+    
+    export function foo() { return "foo" }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (0 errors) ====
+    export function backup() { return "backup"; }
+    
+==== tests/cases/conformance/dynamicImport/2.ts (4 errors) ====
+    declare function bar(): boolean;
+    const specify = bar() ? "./0" : undefined;
+    let myModule = import(specify);
+                          ~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type '"./0" | undefined'.
+    let myModule1 = import(undefined);
+                           ~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+    let myModule2 = import(bar() ? "./1" : null);
+                           ~~~~~~~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type '"./1" | null'.
+    let myModule3 = import(null);
+                           ~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpression5ESNext.js b/tests/baselines/reference/importCallExpression5ESNext.js
new file mode 100644
index 00000000000..1f4c789120b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression5ESNext.js
@@ -0,0 +1,33 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression5ESNext.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare function bar(): boolean;
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
+
+//// [0.js]
+export class B {
+    print() { return "I am B"; }
+}
+export function foo() { return "foo"; }
+//// [1.js]
+export function backup() { return "backup"; }
+//// [2.js]
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
diff --git a/tests/baselines/reference/importCallExpression6ESNext.errors.txt b/tests/baselines/reference/importCallExpression6ESNext.errors.txt
new file mode 100644
index 00000000000..1703e0913d1
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression6ESNext.errors.txt
@@ -0,0 +1,25 @@
+tests/cases/conformance/dynamicImport/2.ts(4,24): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+tests/cases/conformance/dynamicImport/2.ts(6,24): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'null'.
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export class B {
+        print() { return "I am B"}
+    }
+    
+    export function foo() { return "foo" }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (0 errors) ====
+    export function backup() { return "backup"; }
+    
+==== tests/cases/conformance/dynamicImport/2.ts (2 errors) ====
+    declare function bar(): boolean;
+    const specify = bar() ? "./0" : undefined;
+    let myModule = import(specify);
+    let myModule1 = import(undefined);
+                           ~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+    let myModule2 = import(bar() ? "./1" : null);
+    let myModule3 = import(null);
+                           ~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'null'.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpression6ESNext.js b/tests/baselines/reference/importCallExpression6ESNext.js
new file mode 100644
index 00000000000..bdac7328f69
--- /dev/null
+++ b/tests/baselines/reference/importCallExpression6ESNext.js
@@ -0,0 +1,33 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpression6ESNext.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare function bar(): boolean;
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
+
+//// [0.js]
+export class B {
+    print() { return "I am B"; }
+}
+export function foo() { return "foo"; }
+//// [1.js]
+export function backup() { return "backup"; }
+//// [2.js]
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
diff --git a/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt b/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt
new file mode 100644
index 00000000000..39622f39b3f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionCheckReturntype1.errors.txt
@@ -0,0 +1,30 @@
+tests/cases/conformance/dynamicImport/1.ts(4,5): error TS2322: Type 'Promise<typeof "tests/cases/conformance/dynamicImport/defaultPath">' is not assignable to type 'Promise<typeof "tests/cases/conformance/dynamicImport/anotherModule">'.
+  Type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"' is not assignable to type 'typeof "tests/cases/conformance/dynamicImport/anotherModule"'.
+    Property 'D' is missing in type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"'.
+tests/cases/conformance/dynamicImport/1.ts(5,10): error TS2352: Type 'Promise<typeof "tests/cases/conformance/dynamicImport/defaultPath">' cannot be converted to type 'Promise<typeof "tests/cases/conformance/dynamicImport/anotherModule">'.
+  Type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"' is not comparable to type 'typeof "tests/cases/conformance/dynamicImport/anotherModule"'.
+    Property 'D' is missing in type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"'.
+
+
+==== tests/cases/conformance/dynamicImport/anotherModule.ts (0 errors) ====
+    export class D{}
+    
+==== tests/cases/conformance/dynamicImport/defaultPath.ts (0 errors) ====
+    export class C {}
+    
+==== tests/cases/conformance/dynamicImport/1.ts (2 errors) ====
+    import * as defaultModule from "./defaultPath";
+    import * as anotherModule from "./anotherModule";
+    
+    let p1: Promise<typeof anotherModule> = import("./defaultPath");
+        ~~
+!!! error TS2322: Type 'Promise<typeof "tests/cases/conformance/dynamicImport/defaultPath">' is not assignable to type 'Promise<typeof "tests/cases/conformance/dynamicImport/anotherModule">'.
+!!! error TS2322:   Type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"' is not assignable to type 'typeof "tests/cases/conformance/dynamicImport/anotherModule"'.
+!!! error TS2322:     Property 'D' is missing in type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"'.
+    let p2 = import("./defaultPath") as Promise<typeof anotherModule>;
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2352: Type 'Promise<typeof "tests/cases/conformance/dynamicImport/defaultPath">' cannot be converted to type 'Promise<typeof "tests/cases/conformance/dynamicImport/anotherModule">'.
+!!! error TS2352:   Type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"' is not comparable to type 'typeof "tests/cases/conformance/dynamicImport/anotherModule"'.
+!!! error TS2352:     Property 'D' is missing in type 'typeof "tests/cases/conformance/dynamicImport/defaultPath"'.
+    let p3: Promise<any> = import("./defaultPath");
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionCheckReturntype1.js b/tests/baselines/reference/importCallExpressionCheckReturntype1.js
new file mode 100644
index 00000000000..facb6913388
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionCheckReturntype1.js
@@ -0,0 +1,35 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionCheckReturntype1.ts] ////
+
+//// [anotherModule.ts]
+export class D{}
+
+//// [defaultPath.ts]
+export class C {}
+
+//// [1.ts]
+import * as defaultModule from "./defaultPath";
+import * as anotherModule from "./anotherModule";
+
+let p1: Promise<typeof anotherModule> = import("./defaultPath");
+let p2 = import("./defaultPath") as Promise<typeof anotherModule>;
+let p3: Promise<any> = import("./defaultPath");
+
+
+//// [anotherModule.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class D {
+}
+exports.D = D;
+//// [defaultPath.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class C {
+}
+exports.C = C;
+//// [1.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let p1 = Promise.resolve().then(function () { return require("./defaultPath"); });
+let p2 = Promise.resolve().then(function () { return require("./defaultPath"); });
+let p3 = Promise.resolve().then(function () { return require("./defaultPath"); });
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit1.js b/tests/baselines/reference/importCallExpressionDeclarationEmit1.js
new file mode 100644
index 00000000000..07f95d3b3b2
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit1.js
@@ -0,0 +1,35 @@
+//// [importCallExpressionDeclarationEmit1.ts]
+declare function getSpecifier(): string;
+declare var whatToLoad: boolean;
+declare const directory: string;
+declare const moduleFile: number;
+
+import(getSpecifier());
+
+var p0 = import(`${directory}\${moduleFile}`);
+var p1 = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+
+function returnDynamicLoad(path: string) {
+    return import(path);
+}
+
+//// [importCallExpressionDeclarationEmit1.js]
+Promise.resolve().then(function () { return require(getSpecifier()); });
+var p0 = Promise.resolve().then(function () { return require(`${directory}\${moduleFile}`); });
+var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
+const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+function returnDynamicLoad(path) {
+    return Promise.resolve().then(function () { return require(path); });
+}
+
+
+//// [importCallExpressionDeclarationEmit1.d.ts]
+declare function getSpecifier(): string;
+declare var whatToLoad: boolean;
+declare const directory: string;
+declare const moduleFile: number;
+declare var p0: Promise<any>;
+declare var p1: Promise<any>;
+declare const p2: Promise<any>;
+declare function returnDynamicLoad(path: string): Promise<any>;
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit1.symbols b/tests/baselines/reference/importCallExpressionDeclarationEmit1.symbols
new file mode 100644
index 00000000000..d2266cc768b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit1.symbols
@@ -0,0 +1,36 @@
+=== tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit1.ts ===
+declare function getSpecifier(): string;
+>getSpecifier : Symbol(getSpecifier, Decl(importCallExpressionDeclarationEmit1.ts, 0, 0))
+
+declare var whatToLoad: boolean;
+>whatToLoad : Symbol(whatToLoad, Decl(importCallExpressionDeclarationEmit1.ts, 1, 11))
+
+declare const directory: string;
+>directory : Symbol(directory, Decl(importCallExpressionDeclarationEmit1.ts, 2, 13))
+
+declare const moduleFile: number;
+>moduleFile : Symbol(moduleFile, Decl(importCallExpressionDeclarationEmit1.ts, 3, 13))
+
+import(getSpecifier());
+>getSpecifier : Symbol(getSpecifier, Decl(importCallExpressionDeclarationEmit1.ts, 0, 0))
+
+var p0 = import(`${directory}\${moduleFile}`);
+>p0 : Symbol(p0, Decl(importCallExpressionDeclarationEmit1.ts, 7, 3))
+>directory : Symbol(directory, Decl(importCallExpressionDeclarationEmit1.ts, 2, 13))
+
+var p1 = import(getSpecifier());
+>p1 : Symbol(p1, Decl(importCallExpressionDeclarationEmit1.ts, 8, 3))
+>getSpecifier : Symbol(getSpecifier, Decl(importCallExpressionDeclarationEmit1.ts, 0, 0))
+
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+>p2 : Symbol(p2, Decl(importCallExpressionDeclarationEmit1.ts, 9, 5))
+>whatToLoad : Symbol(whatToLoad, Decl(importCallExpressionDeclarationEmit1.ts, 1, 11))
+>getSpecifier : Symbol(getSpecifier, Decl(importCallExpressionDeclarationEmit1.ts, 0, 0))
+
+function returnDynamicLoad(path: string) {
+>returnDynamicLoad : Symbol(returnDynamicLoad, Decl(importCallExpressionDeclarationEmit1.ts, 9, 61))
+>path : Symbol(path, Decl(importCallExpressionDeclarationEmit1.ts, 11, 27))
+
+    return import(path);
+>path : Symbol(path, Decl(importCallExpressionDeclarationEmit1.ts, 11, 27))
+}
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit1.types b/tests/baselines/reference/importCallExpressionDeclarationEmit1.types
new file mode 100644
index 00000000000..db5400818c8
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit1.types
@@ -0,0 +1,47 @@
+=== tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit1.ts ===
+declare function getSpecifier(): string;
+>getSpecifier : () => string
+
+declare var whatToLoad: boolean;
+>whatToLoad : boolean
+
+declare const directory: string;
+>directory : string
+
+declare const moduleFile: number;
+>moduleFile : number
+
+import(getSpecifier());
+>import(getSpecifier()) : Promise<any>
+>getSpecifier() : string
+>getSpecifier : () => string
+
+var p0 = import(`${directory}\${moduleFile}`);
+>p0 : Promise<any>
+>import(`${directory}\${moduleFile}`) : Promise<any>
+>`${directory}\${moduleFile}` : string
+>directory : string
+
+var p1 = import(getSpecifier());
+>p1 : Promise<any>
+>import(getSpecifier()) : Promise<any>
+>getSpecifier() : string
+>getSpecifier : () => string
+
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+>p2 : Promise<any>
+>import(whatToLoad ? getSpecifier() : "defaulPath") : Promise<any>
+>whatToLoad ? getSpecifier() : "defaulPath" : string
+>whatToLoad : boolean
+>getSpecifier() : string
+>getSpecifier : () => string
+>"defaulPath" : "defaulPath"
+
+function returnDynamicLoad(path: string) {
+>returnDynamicLoad : (path: string) => Promise<any>
+>path : string
+
+    return import(path);
+>import(path) : Promise<any>
+>path : string
+}
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit2.errors.txt b/tests/baselines/reference/importCallExpressionDeclarationEmit2.errors.txt
new file mode 100644
index 00000000000..6c394c98bdf
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit2.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/dynamicImport/1.ts(1,5): error TS4023: Exported variable 'p1' has or is using name '"tests/cases/conformance/dynamicImport/0"' from external module "tests/cases/conformance/dynamicImport/0" but cannot be named.
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export function foo() { return "foo"; }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (1 errors) ====
+    var p1 = import("./0");
+        ~~
+!!! error TS4023: Exported variable 'p1' has or is using name '"tests/cases/conformance/dynamicImport/0"' from external module "tests/cases/conformance/dynamicImport/0" but cannot be named.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit2.js b/tests/baselines/reference/importCallExpressionDeclarationEmit2.js
new file mode 100644
index 00000000000..7659e94ee81
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit2.js
@@ -0,0 +1,16 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit2.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+var p1 = import("./0");
+
+//// [0.js]
+export function foo() { return "foo"; }
+//// [1.js]
+var p1 = import("./0");
+
+
+//// [0.d.ts]
+export declare function foo(): string;
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit3.js b/tests/baselines/reference/importCallExpressionDeclarationEmit3.js
new file mode 100644
index 00000000000..d38c2309a33
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit3.js
@@ -0,0 +1,31 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit3.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+declare function getPath(): string;
+import * as Zero from "./0";
+import("./0");
+
+export var p0: Promise<typeof Zero> = import(getPath());
+export var p1: Promise<typeof Zero> = import("./0");
+export var p2: Promise<any> = import("./0");
+
+
+//// [0.js]
+export function foo() { return "foo"; }
+//// [1.js]
+import("./0");
+export var p0 = import(getPath());
+export var p1 = import("./0");
+export var p2 = import("./0");
+
+
+//// [0.d.ts]
+export declare function foo(): string;
+//// [1.d.ts]
+import * as Zero from "./0";
+export declare var p0: Promise<typeof Zero>;
+export declare var p1: Promise<typeof Zero>;
+export declare var p2: Promise<any>;
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit3.symbols b/tests/baselines/reference/importCallExpressionDeclarationEmit3.symbols
new file mode 100644
index 00000000000..1491e05db55
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit3.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+declare function getPath(): string;
+>getPath : Symbol(getPath, Decl(1.ts, 0, 0))
+
+import * as Zero from "./0";
+>Zero : Symbol(Zero, Decl(1.ts, 1, 6))
+
+import("./0");
+
+export var p0: Promise<typeof Zero> = import(getPath());
+>p0 : Symbol(p0, Decl(1.ts, 4, 10))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(1.ts, 1, 6))
+>getPath : Symbol(getPath, Decl(1.ts, 0, 0))
+
+export var p1: Promise<typeof Zero> = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 5, 10))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(1.ts, 1, 6))
+
+export var p2: Promise<any> = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 6, 10))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
diff --git a/tests/baselines/reference/importCallExpressionDeclarationEmit3.types b/tests/baselines/reference/importCallExpressionDeclarationEmit3.types
new file mode 100644
index 00000000000..fe4552b708f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionDeclarationEmit3.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+declare function getPath(): string;
+>getPath : () => string
+
+import * as Zero from "./0";
+>Zero : typeof Zero
+
+import("./0");
+>import("./0") : Promise<typeof Zero>
+>"./0" : "./0"
+
+export var p0: Promise<typeof Zero> = import(getPath());
+>p0 : Promise<typeof Zero>
+>Promise : Promise<T>
+>Zero : typeof Zero
+>import(getPath()) : Promise<any>
+>getPath() : string
+>getPath : () => string
+
+export var p1: Promise<typeof Zero> = import("./0");
+>p1 : Promise<typeof Zero>
+>Promise : Promise<T>
+>Zero : typeof Zero
+>import("./0") : Promise<typeof Zero>
+>"./0" : "./0"
+
+export var p2: Promise<any> = import("./0");
+>p2 : Promise<any>
+>Promise : Promise<T>
+>import("./0") : Promise<typeof Zero>
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.js b/tests/baselines/reference/importCallExpressionES5AMD.js
new file mode 100644
index 00000000000..cce61a5a3f9
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5AMD.js
@@ -0,0 +1,35 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionES5AMD.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+    var p1 = new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    p1.then(function (zero) {
+        return zero.foo();
+    });
+    function foo() {
+        var p2 = new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.symbols b/tests/baselines/reference/importCallExpressionES5AMD.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5AMD.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5AMD.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.js b/tests/baselines/reference/importCallExpressionES5CJS.js
new file mode 100644
index 00000000000..11d1bf46319
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5CJS.js
@@ -0,0 +1,30 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionES5CJS.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+Promise.resolve().then(function () { return require("./0"); });
+var p1 = Promise.resolve().then(function () { return require("./0"); });
+p1.then(function (zero) {
+    return zero.foo();
+});
+function foo() {
+    var p2 = Promise.resolve().then(function () { return require("./0"); });
+}
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.symbols b/tests/baselines/reference/importCallExpressionES5CJS.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5CJS.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5CJS.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionES5System.js b/tests/baselines/reference/importCallExpressionES5System.js
new file mode 100644
index 00000000000..1842fc6e60a
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5System.js
@@ -0,0 +1,46 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionES5System.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    function foo() { return "foo"; }
+    exports_1("foo", foo);
+    return {
+        setters: [],
+        execute: function () {
+        }
+    };
+});
+//// [1.js]
+System.register([], function (exports_1, context_1) {
+    var __moduleName = context_1 && context_1.id;
+    function foo() {
+        var p2 = context_1.import("./0");
+    }
+    var p1;
+    return {
+        setters: [],
+        execute: function () {
+            context_1.import("./0");
+            p1 = context_1.import("./0");
+            p1.then(function (zero) {
+                return zero.foo();
+            });
+        }
+    };
+});
diff --git a/tests/baselines/reference/importCallExpressionES5System.symbols b/tests/baselines/reference/importCallExpressionES5System.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5System.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5System.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.js b/tests/baselines/reference/importCallExpressionES5UMD.js
new file mode 100644
index 00000000000..dfe6813839c
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5UMD.js
@@ -0,0 +1,52 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionES5UMD.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+    var p1 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    p1.then(function (zero) {
+        return zero.foo();
+    });
+    function foo() {
+        var p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.symbols b/tests/baselines/reference/importCallExpressionES5UMD.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5UMD.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionES5UMD.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.errors.txt b/tests/baselines/reference/importCallExpressionErrorInES2015.errors.txt
new file mode 100644
index 00000000000..d47980d1312
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionErrorInES2015.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/dynamicImport/1.ts(1,1): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+tests/cases/conformance/dynamicImport/1.ts(2,10): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+tests/cases/conformance/dynamicImport/1.ts(8,16): error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export function foo() { return "foo"; }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (3 errors) ====
+    import("./0");
+    ~~~~~~~~~~~~~
+!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+    var p1 = import("./0");
+             ~~~~~~~~~~~~~
+!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+    p1.then(zero => {
+        return zero.foo();
+    })
+    
+    function foo() {
+        const p2 = import("./0");
+                   ~~~~~~~~~~~~~
+!!! error TS1323: Dynamic import cannot be used when targeting ECMAScript 2015 modules.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.js b/tests/baselines/reference/importCallExpressionErrorInES2015.js
new file mode 100644
index 00000000000..f07486504ee
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionErrorInES2015.js
@@ -0,0 +1,27 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionErrorInES2015.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+})
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+export function foo() { return "foo"; }
+//// [1.js]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+function foo() {
+    const p2 = import("./0");
+}
diff --git a/tests/baselines/reference/importCallExpressionGrammarError.errors.txt b/tests/baselines/reference/importCallExpressionGrammarError.errors.txt
new file mode 100644
index 00000000000..6d64808e111
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionGrammarError.errors.txt
@@ -0,0 +1,34 @@
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(5,8): error TS1325: Specifier of dynamic import cannot be spread element.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(7,17): error TS1325: Specifier of dynamic import cannot be spread element.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(8,12): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(9,19): error TS1135: Argument expression expected.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(9,19): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(10,12): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts(10,19): error TS2307: Cannot find module 'pathToModule'.
+
+
+==== tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts (7 errors) ====
+    declare function getSpecifier(): string;
+    declare var whatToLoad: boolean;
+    
+    var a = ["./0"];
+    import(...["PathModule"]);
+           ~~~~~~~~~~~~~~~~~
+!!! error TS1325: Specifier of dynamic import cannot be spread element.
+    
+    var p1 = import(...a);
+                    ~~~~
+!!! error TS1325: Specifier of dynamic import cannot be spread element.
+    const p2 = import();
+               ~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    const p3 = import(,);
+                      
+!!! error TS1135: Argument expression expected.
+                      
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'undefined'.
+    const p4 = import("pathToModule", "secondModule");
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find module 'pathToModule'.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionGrammarError.js b/tests/baselines/reference/importCallExpressionGrammarError.js
new file mode 100644
index 00000000000..b30b0c9ddd5
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionGrammarError.js
@@ -0,0 +1,19 @@
+//// [importCallExpressionGrammarError.ts]
+declare function getSpecifier(): string;
+declare var whatToLoad: boolean;
+
+var a = ["./0"];
+import(...["PathModule"]);
+
+var p1 = import(...a);
+const p2 = import();
+const p3 = import(,);
+const p4 = import("pathToModule", "secondModule");
+
+//// [importCallExpressionGrammarError.js]
+var a = ["./0"];
+Promise.resolve().then(function () { return require(...["PathModule"]); });
+var p1 = Promise.resolve().then(function () { return require(...a); });
+const p2 = Promise.resolve().then(function () { return require(); });
+const p3 = Promise.resolve().then(function () { return require(); });
+const p4 = Promise.resolve().then(function () { return require("pathToModule", "secondModule"); });
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.js b/tests/baselines/reference/importCallExpressionInAMD1.js
new file mode 100644
index 00000000000..e1758173646
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD1.js
@@ -0,0 +1,35 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInAMD1.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+    var p1 = new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    p1.then(zero => {
+        return zero.foo();
+    });
+    function foo() {
+        const p2 = new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.symbols b/tests/baselines/reference/importCallExpressionInAMD1.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD1.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD1.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.js b/tests/baselines/reference/importCallExpressionInAMD2.js
new file mode 100644
index 00000000000..7347e2f8105
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD2.js
@@ -0,0 +1,39 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInAMD2.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
+
+//// [0.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+});
+//// [2.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    // We use Promise<any> for now as there is no way to specify shape of module object
+    function foo(x) {
+        x.then(value => {
+            let b = new value.B();
+            b.print();
+        });
+    }
+    foo(new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }));
+});
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.symbols b/tests/baselines/reference/importCallExpressionInAMD2.symbols
new file mode 100644
index 00000000000..16fc79c774f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD2.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    x.then(value => {
+>x.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        let b = new value.B();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        b.print();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+
+    })
+}
+
+foo(import("./0"));
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types
new file mode 100644
index 00000000000..44b17eb51fd
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD2.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : (x: Promise<any>) => void
+>x : Promise<any>
+>Promise : Promise<T>
+
+    x.then(value => {
+>x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>value => {        let b = new value.B();        b.print();    } : (value: any) => void
+>value : any
+
+        let b = new value.B();
+>b : any
+>new value.B() : any
+>value.B : any
+>value : any
+>B : any
+
+        b.print();
+>b.print() : any
+>b.print : any
+>b : any
+>print : any
+
+    })
+}
+
+foo(import("./0"));
+>foo(import("./0")) : void
+>foo : (x: Promise<any>) => void
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionInAMD3.js b/tests/baselines/reference/importCallExpressionInAMD3.js
new file mode 100644
index 00000000000..471f35a6415
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD3.js
@@ -0,0 +1,35 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInAMD3.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
+
+//// [0.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+});
+//// [2.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    async function foo() {
+        class C extends (await new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); })).B {
+        }
+        var c = new C();
+        c.print();
+    }
+    foo();
+});
diff --git a/tests/baselines/reference/importCallExpressionInAMD3.symbols b/tests/baselines/reference/importCallExpressionInAMD3.symbols
new file mode 100644
index 00000000000..5ca85d6e693
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD3.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
+    class C extends (await import("./0")).B {}
+>C : Symbol(C, Decl(2.ts, 0, 22))
+>(await import("./0")).B : Symbol(B, Decl(0.ts, 0, 0))
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    var c = new C();
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>C : Symbol(C, Decl(2.ts, 0, 22))
+
+    c.print();
+>c.print : Symbol(B.print, Decl(0.ts, 0, 16))
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+foo();
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInAMD3.types b/tests/baselines/reference/importCallExpressionInAMD3.types
new file mode 100644
index 00000000000..e517be6e722
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD3.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : () => Promise<void>
+
+    class C extends (await import("./0")).B {}
+>C : C
+>(await import("./0")).B : B
+>(await import("./0")) : typeof "tests/cases/conformance/dynamicImport/0"
+>await import("./0") : typeof "tests/cases/conformance/dynamicImport/0"
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+>B : typeof B
+
+    var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+    c.print();
+>c.print() : string
+>c.print : () => string
+>c : C
+>print : () => string
+}
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.js b/tests/baselines/reference/importCallExpressionInAMD4.js
new file mode 100644
index 00000000000..6e50e139116
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD4.js
@@ -0,0 +1,63 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInAMD4.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
+
+//// [0.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function backup() { return "backup"; }
+    exports.backup = backup;
+});
+//// [2.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    class C {
+        constructor() {
+            this.myModule = new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+        }
+        method() {
+            this.myModule.then(Zero => {
+                console.log(Zero.foo());
+            }, async (err) => {
+                console.log(err);
+                let one = await new Promise(function (resolve_2, reject_2) { require(["./1"], resolve_2, reject_2); });
+                console.log(one.backup());
+            });
+        }
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.symbols b/tests/baselines/reference/importCallExpressionInAMD4.symbols
new file mode 100644
index 00000000000..34a1dcf4d7b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD4.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+export function foo() { return "foo" }
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : Symbol(console, Decl(2.ts, 0, 11))
+
+class C {
+>C : Symbol(C, Decl(2.ts, 0, 25))
+
+    private myModule = import("./0");
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+
+    method() {
+>method : Symbol(C.method, Decl(2.ts, 2, 37))
+
+        this.myModule.then(Zero => {
+>this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this : Symbol(C, Decl(2.ts, 0, 25))
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+
+            console.log(Zero.foo());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+        }, async err => {
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            console.log(err);
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            let one = await import("./1");
+>one : Symbol(one, Decl(2.ts, 8, 15))
+
+            console.log(one.backup());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>one.backup : Symbol(backup, Decl(1.ts, 0, 0))
+>one : Symbol(one, Decl(2.ts, 8, 15))
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types
new file mode 100644
index 00000000000..2ea666ba672
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInAMD4.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+export function foo() { return "foo" }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : any
+
+class C {
+>C : C
+
+    private myModule = import("./0");
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+    method() {
+>method : () => void
+
+        this.myModule.then(Zero => {
+>this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>this : this
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+            console.log(Zero.foo());
+>console.log(Zero.foo()) : any
+>console.log : any
+>console : any
+>log : any
+>Zero.foo() : string
+>Zero.foo : () => string
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+        }, async err => {
+>async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        } : (err: any) => Promise<void>
+>err : any
+
+            console.log(err);
+>console.log(err) : any
+>console.log : any
+>console : any
+>log : any
+>err : any
+
+            let one = await import("./1");
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+            console.log(one.backup());
+>console.log(one.backup()) : any
+>console.log : any
+>console : any
+>log : any
+>one.backup() : string
+>one.backup : () => string
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>backup : () => string
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.js b/tests/baselines/reference/importCallExpressionInCJS1.js
new file mode 100644
index 00000000000..3fb298b5bde
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS1.js
@@ -0,0 +1,30 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInCJS1.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+Promise.resolve().then(function () { return require("./0"); });
+var p1 = Promise.resolve().then(function () { return require("./0"); });
+p1.then(zero => {
+    return zero.foo();
+});
+function foo() {
+    const p2 = Promise.resolve().then(function () { return require("./0"); });
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.symbols b/tests/baselines/reference/importCallExpressionInCJS1.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS1.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS1.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS2.js b/tests/baselines/reference/importCallExpressionInCJS2.js
new file mode 100644
index 00000000000..aa983a7a2fe
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS2.js
@@ -0,0 +1,40 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInCJS2.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+async function compute(promise: Promise<any>) {
+    let j = await promise;
+    if (!j) {
+        j = await import("./1");
+        return j.backup();
+    }
+    return j.foo();
+}
+
+compute(import("./0"));
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function backup() { return "backup"; }
+exports.backup = backup;
+//// [2.js]
+async function compute(promise) {
+    let j = await promise;
+    if (!j) {
+        j = await Promise.resolve().then(function () { return require("./1"); });
+        return j.backup();
+    }
+    return j.foo();
+}
+compute(Promise.resolve().then(function () { return require("./0"); }));
diff --git a/tests/baselines/reference/importCallExpressionInCJS2.symbols b/tests/baselines/reference/importCallExpressionInCJS2.symbols
new file mode 100644
index 00000000000..24f7a5cdb48
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS2.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function compute(promise: Promise<any>) {
+>compute : Symbol(compute, Decl(2.ts, 0, 0))
+>promise : Symbol(promise, Decl(2.ts, 0, 23))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    let j = await promise;
+>j : Symbol(j, Decl(2.ts, 1, 7))
+>promise : Symbol(promise, Decl(2.ts, 0, 23))
+
+    if (!j) {
+>j : Symbol(j, Decl(2.ts, 1, 7))
+
+        j = await import("./1");
+>j : Symbol(j, Decl(2.ts, 1, 7))
+
+        return j.backup();
+>j : Symbol(j, Decl(2.ts, 1, 7))
+    }
+    return j.foo();
+>j : Symbol(j, Decl(2.ts, 1, 7))
+}
+
+compute(import("./0"));
+>compute : Symbol(compute, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS2.types b/tests/baselines/reference/importCallExpressionInCJS2.types
new file mode 100644
index 00000000000..063a5224539
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS2.types
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function compute(promise: Promise<any>) {
+>compute : (promise: Promise<any>) => Promise<any>
+>promise : Promise<any>
+>Promise : Promise<T>
+
+    let j = await promise;
+>j : any
+>await promise : any
+>promise : Promise<any>
+
+    if (!j) {
+>!j : boolean
+>j : any
+
+        j = await import("./1");
+>j = await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>j : any
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+        return j.backup();
+>j.backup() : any
+>j.backup : any
+>j : any
+>backup : any
+    }
+    return j.foo();
+>j.foo() : any
+>j.foo : any
+>j : any
+>foo : any
+}
+
+compute(import("./0"));
+>compute(import("./0")) : Promise<any>
+>compute : (promise: Promise<any>) => Promise<any>
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.js b/tests/baselines/reference/importCallExpressionInCJS3.js
new file mode 100644
index 00000000000..2f956d9ac3a
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS3.js
@@ -0,0 +1,34 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInCJS3.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class B {
+    print() { return "I am B"; }
+}
+exports.B = B;
+//// [2.js]
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    });
+}
+foo(Promise.resolve().then(function () { return require("./0"); }));
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.symbols b/tests/baselines/reference/importCallExpressionInCJS3.symbols
new file mode 100644
index 00000000000..16fc79c774f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS3.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    x.then(value => {
+>x.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        let b = new value.B();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        b.print();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+
+    })
+}
+
+foo(import("./0"));
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types
new file mode 100644
index 00000000000..44b17eb51fd
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS3.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : (x: Promise<any>) => void
+>x : Promise<any>
+>Promise : Promise<T>
+
+    x.then(value => {
+>x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>value => {        let b = new value.B();        b.print();    } : (value: any) => void
+>value : any
+
+        let b = new value.B();
+>b : any
+>new value.B() : any
+>value.B : any
+>value : any
+>B : any
+
+        b.print();
+>b.print() : any
+>b.print : any
+>b : any
+>print : any
+
+    })
+}
+
+foo(import("./0"));
+>foo(import("./0")) : void
+>foo : (x: Promise<any>) => void
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS4.js b/tests/baselines/reference/importCallExpressionInCJS4.js
new file mode 100644
index 00000000000..554a0b222ab
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS4.js
@@ -0,0 +1,30 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInCJS4.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class B {
+    print() { return "I am B"; }
+}
+exports.B = B;
+//// [2.js]
+async function foo() {
+    class C extends (await Promise.resolve().then(function () { return require("./0"); })).B {
+    }
+    var c = new C();
+    c.print();
+}
+foo();
diff --git a/tests/baselines/reference/importCallExpressionInCJS4.symbols b/tests/baselines/reference/importCallExpressionInCJS4.symbols
new file mode 100644
index 00000000000..5ca85d6e693
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS4.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
+    class C extends (await import("./0")).B {}
+>C : Symbol(C, Decl(2.ts, 0, 22))
+>(await import("./0")).B : Symbol(B, Decl(0.ts, 0, 0))
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    var c = new C();
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>C : Symbol(C, Decl(2.ts, 0, 22))
+
+    c.print();
+>c.print : Symbol(B.print, Decl(0.ts, 0, 16))
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+foo();
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS4.types b/tests/baselines/reference/importCallExpressionInCJS4.types
new file mode 100644
index 00000000000..e517be6e722
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS4.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : () => Promise<void>
+
+    class C extends (await import("./0")).B {}
+>C : C
+>(await import("./0")).B : B
+>(await import("./0")) : typeof "tests/cases/conformance/dynamicImport/0"
+>await import("./0") : typeof "tests/cases/conformance/dynamicImport/0"
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+>B : typeof B
+
+    var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+    c.print();
+>c.print() : string
+>c.print : () => string
+>c : C
+>print : () => string
+}
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.js b/tests/baselines/reference/importCallExpressionInCJS5.js
new file mode 100644
index 00000000000..762da592827
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS5.js
@@ -0,0 +1,56 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInCJS5.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class B {
+    print() { return "I am B"; }
+}
+exports.B = B;
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function backup() { return "backup"; }
+exports.backup = backup;
+//// [2.js]
+class C {
+    constructor() {
+        this.myModule = Promise.resolve().then(function () { return require("./0"); });
+    }
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async (err) => {
+            console.log(err);
+            let one = await Promise.resolve().then(function () { return require("./1"); });
+            console.log(one.backup());
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.symbols b/tests/baselines/reference/importCallExpressionInCJS5.symbols
new file mode 100644
index 00000000000..34a1dcf4d7b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS5.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+export function foo() { return "foo" }
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : Symbol(console, Decl(2.ts, 0, 11))
+
+class C {
+>C : Symbol(C, Decl(2.ts, 0, 25))
+
+    private myModule = import("./0");
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+
+    method() {
+>method : Symbol(C.method, Decl(2.ts, 2, 37))
+
+        this.myModule.then(Zero => {
+>this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this : Symbol(C, Decl(2.ts, 0, 25))
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+
+            console.log(Zero.foo());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+        }, async err => {
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            console.log(err);
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            let one = await import("./1");
+>one : Symbol(one, Decl(2.ts, 8, 15))
+
+            console.log(one.backup());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>one.backup : Symbol(backup, Decl(1.ts, 0, 0))
+>one : Symbol(one, Decl(2.ts, 8, 15))
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types
new file mode 100644
index 00000000000..2ea666ba672
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInCJS5.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+export function foo() { return "foo" }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : any
+
+class C {
+>C : C
+
+    private myModule = import("./0");
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+    method() {
+>method : () => void
+
+        this.myModule.then(Zero => {
+>this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>this : this
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+            console.log(Zero.foo());
+>console.log(Zero.foo()) : any
+>console.log : any
+>console : any
+>log : any
+>Zero.foo() : string
+>Zero.foo : () => string
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+        }, async err => {
+>async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        } : (err: any) => Promise<void>
+>err : any
+
+            console.log(err);
+>console.log(err) : any
+>console.log : any
+>console : any
+>log : any
+>err : any
+
+            let one = await import("./1");
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+            console.log(one.backup());
+>console.log(one.backup()) : any
+>console.log : any
+>console : any
+>log : any
+>one.backup() : string
+>one.backup : () => string
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>backup : () => string
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInScriptContext1.js b/tests/baselines/reference/importCallExpressionInScriptContext1.js
new file mode 100644
index 00000000000..2c2d2f904d5
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInScriptContext1.js
@@ -0,0 +1,17 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext1.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+var p1 = import("./0");
+function arguments() { } // this is allow as the file doesn't have implicit "use strict"
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+var p1 = Promise.resolve().then(function () { return require("./0"); });
+function arguments() { } // this is allow as the file doesn't have implicit "use strict"
diff --git a/tests/baselines/reference/importCallExpressionInScriptContext1.symbols b/tests/baselines/reference/importCallExpressionInScriptContext1.symbols
new file mode 100644
index 00000000000..513612056a8
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInScriptContext1.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 0, 3))
+
+function arguments() { } // this is allow as the file doesn't have implicit "use strict"
+>arguments : Symbol(arguments, Decl(1.ts, 0, 23))
+
diff --git a/tests/baselines/reference/importCallExpressionInScriptContext1.types b/tests/baselines/reference/importCallExpressionInScriptContext1.types
new file mode 100644
index 00000000000..c318667c7d8
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInScriptContext1.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+function arguments() { } // this is allow as the file doesn't have implicit "use strict"
+>arguments : () => void
+
diff --git a/tests/baselines/reference/importCallExpressionInScriptContext2.errors.txt b/tests/baselines/reference/importCallExpressionInScriptContext2.errors.txt
new file mode 100644
index 00000000000..9020963f68f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInScriptContext2.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/dynamicImport/1.ts(3,10): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export function foo() { return "foo"; }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (1 errors) ====
+    "use strict"
+    var p1 = import("./0");
+    function arguments() { }
+             ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionInScriptContext2.js b/tests/baselines/reference/importCallExpressionInScriptContext2.js
new file mode 100644
index 00000000000..6b6e0109fda
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInScriptContext2.js
@@ -0,0 +1,19 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext2.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+"use strict"
+var p1 = import("./0");
+function arguments() { }
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+"use strict";
+var p1 = Promise.resolve().then(function () { return require("./0"); });
+function arguments() { }
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.js b/tests/baselines/reference/importCallExpressionInSystem1.js
new file mode 100644
index 00000000000..d74eb6ffc76
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem1.js
@@ -0,0 +1,46 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInSystem1.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    function foo() { return "foo"; }
+    exports_1("foo", foo);
+    return {
+        setters: [],
+        execute: function () {
+        }
+    };
+});
+//// [1.js]
+System.register([], function (exports_1, context_1) {
+    var __moduleName = context_1 && context_1.id;
+    function foo() {
+        const p2 = context_1.import("./0");
+    }
+    var p1;
+    return {
+        setters: [],
+        execute: function () {
+            context_1.import("./0");
+            p1 = context_1.import("./0");
+            p1.then(zero => {
+                return zero.foo();
+            });
+        }
+    };
+});
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.symbols b/tests/baselines/reference/importCallExpressionInSystem1.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem1.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem1.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.js b/tests/baselines/reference/importCallExpressionInSystem2.js
new file mode 100644
index 00000000000..ea84e47e63c
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem2.js
@@ -0,0 +1,50 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInSystem2.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
+
+//// [0.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    var B;
+    return {
+        setters: [],
+        execute: function () {
+            B = class B {
+                print() { return "I am B"; }
+            };
+            exports_1("B", B);
+        }
+    };
+});
+//// [2.js]
+System.register([], function (exports_1, context_1) {
+    var __moduleName = context_1 && context_1.id;
+    // We use Promise<any> for now as there is no way to specify shape of module object
+    function foo(x) {
+        x.then(value => {
+            let b = new value.B();
+            b.print();
+        });
+    }
+    return {
+        setters: [],
+        execute: function () {
+            foo(context_1.import("./0"));
+        }
+    };
+});
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.symbols b/tests/baselines/reference/importCallExpressionInSystem2.symbols
new file mode 100644
index 00000000000..16fc79c774f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem2.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    x.then(value => {
+>x.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        let b = new value.B();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        b.print();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+
+    })
+}
+
+foo(import("./0"));
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types
new file mode 100644
index 00000000000..44b17eb51fd
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem2.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : (x: Promise<any>) => void
+>x : Promise<any>
+>Promise : Promise<T>
+
+    x.then(value => {
+>x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>value => {        let b = new value.B();        b.print();    } : (value: any) => void
+>value : any
+
+        let b = new value.B();
+>b : any
+>new value.B() : any
+>value.B : any
+>value : any
+>B : any
+
+        b.print();
+>b.print() : any
+>b.print : any
+>b : any
+>print : any
+
+    })
+}
+
+foo(import("./0"));
+>foo(import("./0")) : void
+>foo : (x: Promise<any>) => void
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionInSystem3.js b/tests/baselines/reference/importCallExpressionInSystem3.js
new file mode 100644
index 00000000000..309be9114fe
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem3.js
@@ -0,0 +1,46 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInSystem3.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
+
+//// [0.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    var B;
+    return {
+        setters: [],
+        execute: function () {
+            B = class B {
+                print() { return "I am B"; }
+            };
+            exports_1("B", B);
+        }
+    };
+});
+//// [2.js]
+System.register([], function (exports_1, context_1) {
+    var __moduleName = context_1 && context_1.id;
+    async function foo() {
+        class C extends (await context_1.import("./0")).B {
+        }
+        var c = new C();
+        c.print();
+    }
+    return {
+        setters: [],
+        execute: function () {
+            foo();
+        }
+    };
+});
diff --git a/tests/baselines/reference/importCallExpressionInSystem3.symbols b/tests/baselines/reference/importCallExpressionInSystem3.symbols
new file mode 100644
index 00000000000..5ca85d6e693
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem3.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
+    class C extends (await import("./0")).B {}
+>C : Symbol(C, Decl(2.ts, 0, 22))
+>(await import("./0")).B : Symbol(B, Decl(0.ts, 0, 0))
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    var c = new C();
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>C : Symbol(C, Decl(2.ts, 0, 22))
+
+    c.print();
+>c.print : Symbol(B.print, Decl(0.ts, 0, 16))
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+foo();
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInSystem3.types b/tests/baselines/reference/importCallExpressionInSystem3.types
new file mode 100644
index 00000000000..e517be6e722
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem3.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : () => Promise<void>
+
+    class C extends (await import("./0")).B {}
+>C : C
+>(await import("./0")).B : B
+>(await import("./0")) : typeof "tests/cases/conformance/dynamicImport/0"
+>await import("./0") : typeof "tests/cases/conformance/dynamicImport/0"
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+>B : typeof B
+
+    var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+    c.print();
+>c.print() : string
+>c.print : () => string
+>c : C
+>print : () => string
+}
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.js b/tests/baselines/reference/importCallExpressionInSystem4.js
new file mode 100644
index 00000000000..ac01a0439e8
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem4.js
@@ -0,0 +1,80 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInSystem4.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
+
+//// [0.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    function foo() { return "foo"; }
+    exports_1("foo", foo);
+    var B;
+    return {
+        setters: [],
+        execute: function () {
+            B = class B {
+                print() { return "I am B"; }
+            };
+            exports_1("B", B);
+        }
+    };
+});
+//// [1.js]
+System.register([], function (exports_1, context_1) {
+    "use strict";
+    var __moduleName = context_1 && context_1.id;
+    function backup() { return "backup"; }
+    exports_1("backup", backup);
+    return {
+        setters: [],
+        execute: function () {
+        }
+    };
+});
+//// [2.js]
+System.register([], function (exports_1, context_1) {
+    var __moduleName = context_1 && context_1.id;
+    var C;
+    return {
+        setters: [],
+        execute: function () {
+            C = class C {
+                constructor() {
+                    this.myModule = context_1.import("./0");
+                }
+                method() {
+                    this.myModule.then(Zero => {
+                        console.log(Zero.foo());
+                    }, async (err) => {
+                        console.log(err);
+                        let one = await context_1.import("./1");
+                        console.log(one.backup());
+                    });
+                }
+            };
+        }
+    };
+});
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.symbols b/tests/baselines/reference/importCallExpressionInSystem4.symbols
new file mode 100644
index 00000000000..34a1dcf4d7b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem4.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+export function foo() { return "foo" }
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : Symbol(console, Decl(2.ts, 0, 11))
+
+class C {
+>C : Symbol(C, Decl(2.ts, 0, 25))
+
+    private myModule = import("./0");
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+
+    method() {
+>method : Symbol(C.method, Decl(2.ts, 2, 37))
+
+        this.myModule.then(Zero => {
+>this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this : Symbol(C, Decl(2.ts, 0, 25))
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+
+            console.log(Zero.foo());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+        }, async err => {
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            console.log(err);
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            let one = await import("./1");
+>one : Symbol(one, Decl(2.ts, 8, 15))
+
+            console.log(one.backup());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>one.backup : Symbol(backup, Decl(1.ts, 0, 0))
+>one : Symbol(one, Decl(2.ts, 8, 15))
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types
new file mode 100644
index 00000000000..2ea666ba672
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInSystem4.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+export function foo() { return "foo" }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : any
+
+class C {
+>C : C
+
+    private myModule = import("./0");
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+    method() {
+>method : () => void
+
+        this.myModule.then(Zero => {
+>this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>this : this
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+            console.log(Zero.foo());
+>console.log(Zero.foo()) : any
+>console.log : any
+>console : any
+>log : any
+>Zero.foo() : string
+>Zero.foo : () => string
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+        }, async err => {
+>async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        } : (err: any) => Promise<void>
+>err : any
+
+            console.log(err);
+>console.log(err) : any
+>console.log : any
+>console : any
+>log : any
+>err : any
+
+            let one = await import("./1");
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+            console.log(one.backup());
+>console.log(one.backup()) : any
+>console.log : any
+>console : any
+>log : any
+>one.backup() : string
+>one.backup : () => string
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>backup : () => string
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.js b/tests/baselines/reference/importCallExpressionInUMD1.js
new file mode 100644
index 00000000000..f1bfcd3cc71
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD1.js
@@ -0,0 +1,52 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInUMD1.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
+
+//// [0.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+    var p1 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    p1.then(zero => {
+        return zero.foo();
+    });
+    function foo() {
+        const p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.symbols b/tests/baselines/reference/importCallExpressionInUMD1.symbols
new file mode 100644
index 00000000000..333251da662
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD1.symbols
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+var p1 = import("./0");
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 1, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+
+    return zero.foo();
+>zero.foo : Symbol(foo, Decl(0.ts, 0, 0))
+>zero : Symbol(zero, Decl(1.ts, 2, 8))
+>foo : Symbol(foo, Decl(0.ts, 0, 0))
+
+});
+
+function foo() {
+>foo : Symbol(foo, Decl(1.ts, 4, 3))
+
+    const p2 = import("./0");
+>p2 : Symbol(p2, Decl(1.ts, 7, 9))
+}
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types
new file mode 100644
index 00000000000..59da055ee01
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD1.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export function foo() { return "foo"; }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import("./0");
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+var p1 = import("./0");
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();}) : Promise<string>
+>p1.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();} : (zero: typeof "tests/cases/conformance/dynamicImport/0") => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+    return zero.foo();
+>zero.foo() : string
+>zero.foo : () => string
+>zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+});
+
+function foo() {
+>foo : () => void
+
+    const p2 = import("./0");
+>p2 : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+}
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.js b/tests/baselines/reference/importCallExpressionInUMD2.js
new file mode 100644
index 00000000000..db8b87a2f79
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD2.js
@@ -0,0 +1,56 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInUMD2.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
+
+//// [0.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+});
+//// [2.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    // We use Promise<any> for now as there is no way to specify shape of module object
+    function foo(x) {
+        x.then(value => {
+            let b = new value.B();
+            b.print();
+        });
+    }
+    foo(__syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }));
+});
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.symbols b/tests/baselines/reference/importCallExpressionInUMD2.symbols
new file mode 100644
index 00000000000..16fc79c774f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD2.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    x.then(value => {
+>x.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(2.ts, 1, 13))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        let b = new value.B();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+>value : Symbol(value, Decl(2.ts, 2, 11))
+
+        b.print();
+>b : Symbol(b, Decl(2.ts, 3, 11))
+
+    })
+}
+
+foo(import("./0"));
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types
new file mode 100644
index 00000000000..44b17eb51fd
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD2.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+>foo : (x: Promise<any>) => void
+>x : Promise<any>
+>Promise : Promise<T>
+
+    x.then(value => {
+>x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
+>x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>x : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>value => {        let b = new value.B();        b.print();    } : (value: any) => void
+>value : any
+
+        let b = new value.B();
+>b : any
+>new value.B() : any
+>value.B : any
+>value : any
+>B : any
+
+        b.print();
+>b.print() : any
+>b.print : any
+>b : any
+>print : any
+
+    })
+}
+
+foo(import("./0"));
+>foo(import("./0")) : void
+>foo : (x: Promise<any>) => void
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
diff --git a/tests/baselines/reference/importCallExpressionInUMD3.js b/tests/baselines/reference/importCallExpressionInUMD3.js
new file mode 100644
index 00000000000..41106e3ab78
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD3.js
@@ -0,0 +1,52 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInUMD3.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+//// [2.ts]
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
+
+//// [0.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+});
+//// [2.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    async function foo() {
+        class C extends (await (__syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }))).B {
+        }
+        var c = new C();
+        c.print();
+    }
+    foo();
+});
diff --git a/tests/baselines/reference/importCallExpressionInUMD3.symbols b/tests/baselines/reference/importCallExpressionInUMD3.symbols
new file mode 100644
index 00000000000..5ca85d6e693
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD3.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
+    class C extends (await import("./0")).B {}
+>C : Symbol(C, Decl(2.ts, 0, 22))
+>(await import("./0")).B : Symbol(B, Decl(0.ts, 0, 0))
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    var c = new C();
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>C : Symbol(C, Decl(2.ts, 0, 22))
+
+    c.print();
+>c.print : Symbol(B.print, Decl(0.ts, 0, 16))
+>c : Symbol(c, Decl(2.ts, 2, 7))
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+foo();
+>foo : Symbol(foo, Decl(2.ts, 0, 0))
+
diff --git a/tests/baselines/reference/importCallExpressionInUMD3.types b/tests/baselines/reference/importCallExpressionInUMD3.types
new file mode 100644
index 00000000000..e517be6e722
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD3.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+async function foo() {
+>foo : () => Promise<void>
+
+    class C extends (await import("./0")).B {}
+>C : C
+>(await import("./0")).B : B
+>(await import("./0")) : typeof "tests/cases/conformance/dynamicImport/0"
+>await import("./0") : typeof "tests/cases/conformance/dynamicImport/0"
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+>B : typeof B
+
+    var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+    c.print();
+>c.print() : string
+>c.print : () => string
+>c : C
+>print : () => string
+}
+foo();
+>foo() : Promise<void>
+>foo : () => Promise<void>
+
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.js b/tests/baselines/reference/importCallExpressionInUMD4.js
new file mode 100644
index 00000000000..47ba83b1718
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD4.js
@@ -0,0 +1,88 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionInUMD4.ts] ////
+
+//// [0.ts]
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+//// [1.ts]
+export function backup() { return "backup"; }
+
+//// [2.ts]
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
+
+//// [0.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class B {
+        print() { return "I am B"; }
+    }
+    exports.B = B;
+    function foo() { return "foo"; }
+    exports.foo = foo;
+});
+//// [1.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function backup() { return "backup"; }
+    exports.backup = backup;
+});
+//// [2.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    class C {
+        constructor() {
+            this.myModule = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+        }
+        method() {
+            this.myModule.then(Zero => {
+                console.log(Zero.foo());
+            }, async (err) => {
+                console.log(err);
+                let one = await (__syncRequire ? Promise.resolve().then(function () { return require("./1"); }) : new Promise(function (resolve_2, reject_2) { require(["./1"], resolve_2, reject_2); }));
+                console.log(one.backup());
+            });
+        }
+    }
+});
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.symbols b/tests/baselines/reference/importCallExpressionInUMD4.symbols
new file mode 100644
index 00000000000..34a1dcf4d7b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD4.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : Symbol(B, Decl(0.ts, 0, 0))
+
+    print() { return "I am B"}
+>print : Symbol(B.print, Decl(0.ts, 0, 16))
+}
+
+export function foo() { return "foo" }
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : Symbol(console, Decl(2.ts, 0, 11))
+
+class C {
+>C : Symbol(C, Decl(2.ts, 0, 25))
+
+    private myModule = import("./0");
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+
+    method() {
+>method : Symbol(C.method, Decl(2.ts, 2, 37))
+
+        this.myModule.then(Zero => {
+>this.myModule.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>this.myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>this : Symbol(C, Decl(2.ts, 0, 25))
+>myModule : Symbol(C.myModule, Decl(2.ts, 1, 9))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+
+            console.log(Zero.foo());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>Zero.foo : Symbol(foo, Decl(0.ts, 2, 1))
+>Zero : Symbol(Zero, Decl(2.ts, 4, 27))
+>foo : Symbol(foo, Decl(0.ts, 2, 1))
+
+        }, async err => {
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            console.log(err);
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>err : Symbol(err, Decl(2.ts, 6, 16))
+
+            let one = await import("./1");
+>one : Symbol(one, Decl(2.ts, 8, 15))
+
+            console.log(one.backup());
+>console : Symbol(console, Decl(2.ts, 0, 11))
+>one.backup : Symbol(backup, Decl(1.ts, 0, 0))
+>one : Symbol(one, Decl(2.ts, 8, 15))
+>backup : Symbol(backup, Decl(1.ts, 0, 0))
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types
new file mode 100644
index 00000000000..2ea666ba672
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionInUMD4.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/dynamicImport/0.ts ===
+export class B {
+>B : B
+
+    print() { return "I am B"}
+>print : () => string
+>"I am B" : "I am B"
+}
+
+export function foo() { return "foo" }
+>foo : () => string
+>"foo" : "foo"
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+export function backup() { return "backup"; }
+>backup : () => string
+>"backup" : "backup"
+
+=== tests/cases/conformance/dynamicImport/2.ts ===
+declare var console: any;
+>console : any
+
+class C {
+>C : C
+
+    private myModule = import("./0");
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>import("./0") : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>"./0" : "./0"
+
+    method() {
+>method : () => void
+
+        this.myModule.then(Zero => {
+>this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
+>this.myModule.then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>this.myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>this : this
+>myModule : Promise<typeof "tests/cases/conformance/dynamicImport/0">
+>then : <TResult1 = typeof "tests/cases/conformance/dynamicImport/0", TResult2 = never>(onfulfilled?: (value: typeof "tests/cases/conformance/dynamicImport/0") => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>Zero => {            console.log(Zero.foo());        } : (Zero: typeof "tests/cases/conformance/dynamicImport/0") => void
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+
+            console.log(Zero.foo());
+>console.log(Zero.foo()) : any
+>console.log : any
+>console : any
+>log : any
+>Zero.foo() : string
+>Zero.foo : () => string
+>Zero : typeof "tests/cases/conformance/dynamicImport/0"
+>foo : () => string
+
+        }, async err => {
+>async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        } : (err: any) => Promise<void>
+>err : any
+
+            console.log(err);
+>console.log(err) : any
+>console.log : any
+>console : any
+>log : any
+>err : any
+
+            let one = await import("./1");
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>await import("./1") : typeof "tests/cases/conformance/dynamicImport/1"
+>import("./1") : Promise<typeof "tests/cases/conformance/dynamicImport/1">
+>"./1" : "./1"
+
+            console.log(one.backup());
+>console.log(one.backup()) : any
+>console.log : any
+>console : any
+>log : any
+>one.backup() : string
+>one.backup : () => string
+>one : typeof "tests/cases/conformance/dynamicImport/1"
+>backup : () => string
+
+        });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.js b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.js
new file mode 100644
index 00000000000..728d6636953
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.js
@@ -0,0 +1,61 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionReturnPromiseOfAny.ts] ////
+
+//// [defaultPath.ts]
+export class C {}
+
+//// [1.ts]
+import * as defaultModule from "./defaultPath";
+declare function getSpecifier(): string;
+declare function ValidSomeCondition(): boolean;
+declare var whatToLoad: boolean;
+declare const directory: string;
+declare const moduleFile: number;
+
+import(`${directory}\${moduleFile}`);
+import(getSpecifier());
+
+var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
+var p1: Promise<any> = import(getSpecifier());
+var p11: Promise<typeof defaultModule> = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
+p1.then(zero => {
+    return zero.foo();  // ok, zero is any
+});
+
+let j: string;
+var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
+
+function * loadModule(directories: string[]) {
+    for (const directory of directories) {
+        const path = `${directory}\moduleFile`;
+        import(yield path);
+    }
+}
+
+
+//// [defaultPath.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class C {
+}
+exports.C = C;
+//// [1.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Promise.resolve().then(function () { return require(`${directory}\${moduleFile}`); });
+Promise.resolve().then(function () { return require(getSpecifier()); });
+var p1 = Promise.resolve().then(function () { return require(ValidSomeCondition() ? "./0" : "externalModule"); });
+var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
+var p11 = Promise.resolve().then(function () { return require(getSpecifier()); });
+const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+p1.then(zero => {
+    return zero.foo(); // ok, zero is any
+});
+let j;
+var p3 = Promise.resolve().then(function () { return require(j = getSpecifier()); });
+function* loadModule(directories) {
+    for (const directory of directories) {
+        const path = `${directory}\moduleFile`;
+        Promise.resolve().then(function () { return require(yield path); });
+    }
+}
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols
new file mode 100644
index 00000000000..0d46961475f
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.symbols
@@ -0,0 +1,89 @@
+=== tests/cases/conformance/dynamicImport/defaultPath.ts ===
+export class C {}
+>C : Symbol(C, Decl(defaultPath.ts, 0, 0))
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import * as defaultModule from "./defaultPath";
+>defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
+
+declare function getSpecifier(): string;
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+
+declare function ValidSomeCondition(): boolean;
+>ValidSomeCondition : Symbol(ValidSomeCondition, Decl(1.ts, 1, 40))
+
+declare var whatToLoad: boolean;
+>whatToLoad : Symbol(whatToLoad, Decl(1.ts, 3, 11))
+
+declare const directory: string;
+>directory : Symbol(directory, Decl(1.ts, 4, 13))
+
+declare const moduleFile: number;
+>moduleFile : Symbol(moduleFile, Decl(1.ts, 5, 13))
+
+import(`${directory}\${moduleFile}`);
+>directory : Symbol(directory, Decl(1.ts, 4, 13))
+
+import(getSpecifier());
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+
+var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
+>p1 : Symbol(p1, Decl(1.ts, 10, 3), Decl(1.ts, 11, 3))
+>ValidSomeCondition : Symbol(ValidSomeCondition, Decl(1.ts, 1, 40))
+
+var p1: Promise<any> = import(getSpecifier());
+>p1 : Symbol(p1, Decl(1.ts, 10, 3), Decl(1.ts, 11, 3))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+
+var p11: Promise<typeof defaultModule> = import(getSpecifier());
+>p11 : Symbol(p11, Decl(1.ts, 12, 3))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
+>p2 : Symbol(p2, Decl(1.ts, 13, 5))
+>whatToLoad : Symbol(whatToLoad, Decl(1.ts, 3, 11))
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
+
+p1.then(zero => {
+>p1.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>p1 : Symbol(p1, Decl(1.ts, 10, 3), Decl(1.ts, 11, 3))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>zero : Symbol(zero, Decl(1.ts, 14, 8))
+
+    return zero.foo();  // ok, zero is any
+>zero : Symbol(zero, Decl(1.ts, 14, 8))
+
+});
+
+let j: string;
+>j : Symbol(j, Decl(1.ts, 18, 3))
+
+var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
+>p3 : Symbol(p3, Decl(1.ts, 19, 3))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>defaultModule : Symbol(defaultModule, Decl(1.ts, 0, 6))
+>j : Symbol(j, Decl(1.ts, 18, 3))
+>getSpecifier : Symbol(getSpecifier, Decl(1.ts, 0, 47))
+
+function * loadModule(directories: string[]) {
+>loadModule : Symbol(loadModule, Decl(1.ts, 19, 65))
+>directories : Symbol(directories, Decl(1.ts, 21, 22))
+
+    for (const directory of directories) {
+>directory : Symbol(directory, Decl(1.ts, 22, 14))
+>directories : Symbol(directories, Decl(1.ts, 21, 22))
+
+        const path = `${directory}\moduleFile`;
+>path : Symbol(path, Decl(1.ts, 23, 13))
+>directory : Symbol(directory, Decl(1.ts, 22, 14))
+
+        import(yield path);
+>path : Symbol(path, Decl(1.ts, 23, 13))
+    }
+}
+
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
new file mode 100644
index 00000000000..fc52b38c1fb
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -0,0 +1,118 @@
+=== tests/cases/conformance/dynamicImport/defaultPath.ts ===
+export class C {}
+>C : C
+
+=== tests/cases/conformance/dynamicImport/1.ts ===
+import * as defaultModule from "./defaultPath";
+>defaultModule : typeof defaultModule
+
+declare function getSpecifier(): string;
+>getSpecifier : () => string
+
+declare function ValidSomeCondition(): boolean;
+>ValidSomeCondition : () => boolean
+
+declare var whatToLoad: boolean;
+>whatToLoad : boolean
+
+declare const directory: string;
+>directory : string
+
+declare const moduleFile: number;
+>moduleFile : number
+
+import(`${directory}\${moduleFile}`);
+>import(`${directory}\${moduleFile}`) : Promise<any>
+>`${directory}\${moduleFile}` : string
+>directory : string
+
+import(getSpecifier());
+>import(getSpecifier()) : Promise<any>
+>getSpecifier() : string
+>getSpecifier : () => string
+
+var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
+>p1 : Promise<any>
+>import(ValidSomeCondition() ? "./0" : "externalModule") : Promise<any>
+>ValidSomeCondition() ? "./0" : "externalModule" : "./0" | "externalModule"
+>ValidSomeCondition() : boolean
+>ValidSomeCondition : () => boolean
+>"./0" : "./0"
+>"externalModule" : "externalModule"
+
+var p1: Promise<any> = import(getSpecifier());
+>p1 : Promise<any>
+>Promise : Promise<T>
+>import(getSpecifier()) : Promise<any>
+>getSpecifier() : string
+>getSpecifier : () => string
+
+var p11: Promise<typeof defaultModule> = import(getSpecifier());
+>p11 : Promise<typeof defaultModule>
+>Promise : Promise<T>
+>defaultModule : typeof defaultModule
+>import(getSpecifier()) : Promise<any>
+>getSpecifier() : string
+>getSpecifier : () => string
+
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
+>p2 : Promise<typeof defaultModule>
+>import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule> : Promise<typeof defaultModule>
+>import(whatToLoad ? getSpecifier() : "defaulPath") : Promise<any>
+>whatToLoad ? getSpecifier() : "defaulPath" : string
+>whatToLoad : boolean
+>getSpecifier() : string
+>getSpecifier : () => string
+>"defaulPath" : "defaulPath"
+>Promise : Promise<T>
+>defaultModule : typeof defaultModule
+
+p1.then(zero => {
+>p1.then(zero => {    return zero.foo();  // ok, zero is any}) : Promise<any>
+>p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>p1 : Promise<any>
+>then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
+>zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
+>zero : any
+
+    return zero.foo();  // ok, zero is any
+>zero.foo() : any
+>zero.foo : any
+>zero : any
+>foo : any
+
+});
+
+let j: string;
+>j : string
+
+var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
+>p3 : Promise<typeof defaultModule>
+>Promise : Promise<T>
+>defaultModule : typeof defaultModule
+>import(j=getSpecifier()) : Promise<any>
+>j=getSpecifier() : string
+>j : string
+>getSpecifier() : string
+>getSpecifier : () => string
+
+function * loadModule(directories: string[]) {
+>loadModule : (directories: string[]) => IterableIterator<string>
+>directories : string[]
+
+    for (const directory of directories) {
+>directory : string
+>directories : string[]
+
+        const path = `${directory}\moduleFile`;
+>path : string
+>`${directory}\moduleFile` : string
+>directory : string
+
+        import(yield path);
+>import(yield path) : Promise<any>
+>yield path : any
+>path : string
+    }
+}
+
diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.errors.txt b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.errors.txt
new file mode 100644
index 00000000000..a1159a31ebd
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.errors.txt
@@ -0,0 +1,31 @@
+tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts(5,8): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean'.
+tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts(6,17): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean'.
+tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts(7,19): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean | "defaulPath"'.
+tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts(12,17): error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'string[]'.
+tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts(13,17): error TS7036: Dynamic import's specifier must be of type 'string', but here has type '() => string'.
+
+
+==== tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts (5 errors) ====
+    declare function getSpecifier(): boolean;
+    declare var whatToLoad: boolean;
+    
+    // Error specifier is not assignable to string
+    import(getSpecifier());
+           ~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean'.
+    var p1 = import(getSpecifier());
+                    ~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean'.
+    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'boolean | "defaulPath"'.
+    p1.then(zero => {
+        return zero.foo();  // ok, zero is any
+    });
+    
+    var p3 = import(["path1", "path2"]);
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type 'string[]'.
+    var p4 = import(()=>"PathToModule");
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS7036: Dynamic import's specifier must be of type 'string', but here has type '() => string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.js b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.js
new file mode 100644
index 00000000000..dde35d8048b
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.js
@@ -0,0 +1,25 @@
+//// [importCallExpressionSpecifierNotStringTypeError.ts]
+declare function getSpecifier(): boolean;
+declare var whatToLoad: boolean;
+
+// Error specifier is not assignable to string
+import(getSpecifier());
+var p1 = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+p1.then(zero => {
+    return zero.foo();  // ok, zero is any
+});
+
+var p3 = import(["path1", "path2"]);
+var p4 = import(()=>"PathToModule");
+
+//// [importCallExpressionSpecifierNotStringTypeError.js]
+// Error specifier is not assignable to string
+Promise.resolve().then(function () { return require(getSpecifier()); });
+var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
+const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+p1.then(zero => {
+    return zero.foo(); // ok, zero is any
+});
+var p3 = Promise.resolve().then(function () { return require(["path1", "path2"]); });
+var p4 = Promise.resolve().then(function () { return require(() => "PathToModule"); });
diff --git a/tests/baselines/reference/importCallExpressionWithTypeArgument.errors.txt b/tests/baselines/reference/importCallExpressionWithTypeArgument.errors.txt
new file mode 100644
index 00000000000..8adf2789585
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionWithTypeArgument.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/conformance/dynamicImport/1.ts(2,10): error TS1326: Dynamic import cannot have type arguments
+tests/cases/conformance/dynamicImport/1.ts(3,10): error TS1326: Dynamic import cannot have type arguments
+
+
+==== tests/cases/conformance/dynamicImport/0.ts (0 errors) ====
+    export function foo() { return "foo"; }
+    
+==== tests/cases/conformance/dynamicImport/1.ts (2 errors) ====
+    "use strict"
+    var p1 = import<Promise<any>>("./0");  // error
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1326: Dynamic import cannot have type arguments
+    var p2 = import<>("./0");  // error
+             ~~~~~~~~~~~~~~~
+!!! error TS1326: Dynamic import cannot have type arguments
+    // p1.then(value => {
+    //     value.anyFunction();
+    // })
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionWithTypeArgument.js b/tests/baselines/reference/importCallExpressionWithTypeArgument.js
new file mode 100644
index 00000000000..d8690cf5d75
--- /dev/null
+++ b/tests/baselines/reference/importCallExpressionWithTypeArgument.js
@@ -0,0 +1,22 @@
+//// [tests/cases/conformance/dynamicImport/importCallExpressionWithTypeArgument.ts] ////
+
+//// [0.ts]
+export function foo() { return "foo"; }
+
+//// [1.ts]
+"use strict"
+var p1 = import<Promise<any>>("./0");  // error
+var p2 = import<>("./0");  // error
+// p1.then(value => {
+//     value.anyFunction();
+// })
+
+//// [0.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function foo() { return "foo"; }
+exports.foo = foo;
+//// [1.js]
+"use strict";
+var p1 = (import)("./0"); // error
+var p2 = (import)("./0"); // error
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.symbols b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.symbols
index 79a855badb5..7e4fe043b93 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.symbols
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.symbols
@@ -103,8 +103,8 @@ foo(wrap(s => s.length));
 
 let a1 = ["a", "b"].map(s => s.length);
 >a1 : Symbol(a1, Decl(inferFromGenericFunctionReturnTypes2.ts, 17, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 17, 24))
 >s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 17, 24))
@@ -112,8 +112,8 @@ let a1 = ["a", "b"].map(s => s.length);
 
 let a2 = ["a", "b"].map(wrap(s => s.length));
 >a2 : Symbol(a2, Decl(inferFromGenericFunctionReturnTypes2.ts, 18, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >wrap : Symbol(wrap, Decl(inferFromGenericFunctionReturnTypes2.ts, 0, 32))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 18, 29))
 >s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
@@ -122,8 +122,8 @@ let a2 = ["a", "b"].map(wrap(s => s.length));
 
 let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 >a3 : Symbol(a3, Decl(inferFromGenericFunctionReturnTypes2.ts, 19, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >wrap : Symbol(wrap, Decl(inferFromGenericFunctionReturnTypes2.ts, 0, 32))
 >arrayize : Symbol(arrayize, Decl(inferFromGenericFunctionReturnTypes2.ts, 2, 60))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 19, 38))
@@ -133,8 +133,8 @@ let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 
 let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 >a4 : Symbol(a4, Decl(inferFromGenericFunctionReturnTypes2.ts, 20, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >combine : Symbol(combine, Decl(inferFromGenericFunctionReturnTypes2.ts, 4, 66))
 >wrap : Symbol(wrap, Decl(inferFromGenericFunctionReturnTypes2.ts, 0, 32))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 20, 37))
@@ -147,8 +147,8 @@ let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 
 let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 >a5 : Symbol(a5, Decl(inferFromGenericFunctionReturnTypes2.ts, 21, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >combine : Symbol(combine, Decl(inferFromGenericFunctionReturnTypes2.ts, 4, 66))
 >identity : Symbol(identity, Decl(inferFromGenericFunctionReturnTypes2.ts, 82, 1))
 >wrap : Symbol(wrap, Decl(inferFromGenericFunctionReturnTypes2.ts, 0, 32))
@@ -159,8 +159,8 @@ let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 
 let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
 >a6 : Symbol(a6, Decl(inferFromGenericFunctionReturnTypes2.ts, 22, 3))
->["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["a", "b"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >combine : Symbol(combine, Decl(inferFromGenericFunctionReturnTypes2.ts, 4, 66))
 >wrap : Symbol(wrap, Decl(inferFromGenericFunctionReturnTypes2.ts, 0, 32))
 >s : Symbol(s, Decl(inferFromGenericFunctionReturnTypes2.ts, 22, 37))
@@ -217,11 +217,11 @@ class SetOf<A> {
 >index : Symbol(index, Decl(inferFromGenericFunctionReturnTypes2.ts, 36, 20))
 
       this._store.forEach((a, i) => fn(a, i));
->this._store.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>this._store.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >this._store : Symbol(SetOf._store, Decl(inferFromGenericFunctionReturnTypes2.ts, 25, 16))
 >this : Symbol(SetOf, Decl(inferFromGenericFunctionReturnTypes2.ts, 22, 64))
 >_store : Symbol(SetOf._store, Decl(inferFromGenericFunctionReturnTypes2.ts, 25, 16))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(inferFromGenericFunctionReturnTypes2.ts, 37, 27))
 >i : Symbol(i, Decl(inferFromGenericFunctionReturnTypes2.ts, 37, 29))
 >fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes2.ts, 36, 10))
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
index a07c5ea4db8..cf7752e237e 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
@@ -120,12 +120,12 @@ foo(wrap(s => s.length));
 let a1 = ["a", "b"].map(s => s.length);
 >a1 : number[]
 >["a", "b"].map(s => s.length) : number[]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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.length : (this: void, s: string) => number
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s => s.length : (s: string) => number
 >s : string
 >s.length : number
 >s : string
@@ -134,11 +134,11 @@ let a1 = ["a", "b"].map(s => s.length);
 let a2 = ["a", "b"].map(wrap(s => s.length));
 >a2 : number[]
 >["a", "b"].map(wrap(s => s.length)) : number[]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >wrap(s => s.length) : Mapper<string, number>
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
 >s => s.length : (s: string) => number
@@ -150,11 +150,11 @@ let a2 = ["a", "b"].map(wrap(s => s.length));
 let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 >a3 : number[][]
 >["a", "b"].map(wrap(arrayize(s => s.length))) : number[][]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >wrap(arrayize(s => s.length)) : Mapper<string, number[]>
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
 >arrayize(s => s.length) : Mapper<string, number[]>
@@ -168,11 +168,11 @@ let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 >a4 : boolean[]
 >["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10))) : boolean[]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(wrap(s => s.length), wrap(n => n > 10)) : (x: string) => boolean
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >wrap(s => s.length) : Mapper<string, number>
@@ -193,11 +193,11 @@ let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 >a5 : number[]
 >["a", "b"].map(combine(identity, wrap(s => s.length))) : number[]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(identity, wrap(s => s.length)) : (x: string) => number
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >identity : <T>(x: T) => T
@@ -212,11 +212,11 @@ let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
 >a6 : number[]
 >["a", "b"].map(combine(wrap(s => s.length), identity)) : number[]
->["a", "b"].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"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->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[]; }
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(wrap(s => s.length), identity) : (x: string) => number
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >wrap(s => s.length) : Mapper<string, number>
@@ -279,12 +279,12 @@ class SetOf<A> {
 
       this._store.forEach((a, i) => fn(a, i));
 >this._store.forEach((a, i) => fn(a, i)) : void
->this._store.forEach : { (callbackfn: (this: void, value: A, index: number, array: A[]) => void): void; (callbackfn: (this: void, value: A, index: number, array: A[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: A, index: number, array: A[]) => void, thisArg: Z): void; }
+>this._store.forEach : (callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
 >this._store : A[]
 >this : this
 >_store : A[]
->forEach : { (callbackfn: (this: void, value: A, index: number, array: A[]) => void): void; (callbackfn: (this: void, value: A, index: number, array: A[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: A, index: number, array: A[]) => void, thisArg: Z): void; }
->(a, i) => fn(a, i) : (this: void, a: A, i: number) => void
+>forEach : (callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
+>(a, i) => fn(a, i) : (a: A, i: number) => void
 >a : A
 >i : number
 >fn(a, i) : void
diff --git a/tests/baselines/reference/inferenceLimit.symbols b/tests/baselines/reference/inferenceLimit.symbols
index e471856e448..70bbad69b3e 100644
--- a/tests/baselines/reference/inferenceLimit.symbols
+++ b/tests/baselines/reference/inferenceLimit.symbols
@@ -64,9 +64,9 @@ export class BrokenClass {
 >Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(file1.ts, 10, 7))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >populateItems : Symbol(populateItems, Decl(file1.ts, 12, 7))
 
       .then((orders: Array<MyModule.MyModel>) => {
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index c7cb6d8333e..667d322f547 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: 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.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
->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[]; }
+>map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >populateItems : (order: any) => Promise<{}>
 
       .then((orders: Array<MyModule.MyModel>) => {
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
index fe60a8c1581..c6ac17b0ccb 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
@@ -11,7 +11,7 @@ function identity<A>(a: A): A {
 }
 var x = [1, 2, 3].map(identity)[0];
 >x : Symbol(x, Decl(inferentialTypingWithFunctionType2.ts, 3, 3))
->[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionType2.ts, 0, 0))
 
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.types b/tests/baselines/reference/inferentialTypingWithFunctionType2.types
index 90c84817922..2c4bb2542fb 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: 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].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 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[]; }
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >identity : <A>(a: A) => A
 >0 : 0
 
diff --git a/tests/baselines/reference/jsDocTypes2.symbols b/tests/baselines/reference/jsDocTypes2.symbols
deleted file mode 100644
index 8f4dc4e7b43..00000000000
--- a/tests/baselines/reference/jsDocTypes2.symbols
+++ /dev/null
@@ -1,49 +0,0 @@
-=== tests/cases/conformance/salsa/0.js ===
-// @ts-check
-/** @type {*} */
-var anyT = 2;
->anyT : Symbol(anyT, Decl(0.js, 2, 3))
-
-/** @type {?} */
-var anyT1 = 2;
->anyT1 : Symbol(anyT1, Decl(0.js, 5, 3))
-
-anyT1 = "hi";
->anyT1 : Symbol(anyT1, Decl(0.js, 5, 3))
-
-/** @type {Function} */
-const x = (a) => a + 1;
->x : Symbol(x, Decl(0.js, 9, 5))
->a : Symbol(a, Decl(0.js, 9, 11))
->a : Symbol(a, Decl(0.js, 9, 11))
-
-x(1);
->x : Symbol(x, Decl(0.js, 9, 5))
-
-/** @type {function} */
-const y = (a) => a + 1;
->y : Symbol(y, Decl(0.js, 13, 5))
->a : Symbol(a, Decl(0.js, 13, 11))
->a : Symbol(a, Decl(0.js, 13, 11))
-
-x(1);
->x : Symbol(x, Decl(0.js, 9, 5))
-
-/** @type {function (number)} */
-const x1 = (a) => a + 1;
->x1 : Symbol(x1, Decl(0.js, 17, 5))
->a : Symbol(a, Decl(0.js, 17, 12))
->a : Symbol(a, Decl(0.js, 17, 12))
-
-x1(0);
->x1 : Symbol(x1, Decl(0.js, 17, 5))
-
-/** @type {function (number): number} */
-const x2 = (a) => a + 1;
->x2 : Symbol(x2, Decl(0.js, 21, 5))
->a : Symbol(a, Decl(0.js, 21, 12))
->a : Symbol(a, Decl(0.js, 21, 12))
-
-x2(0);
->x2 : Symbol(x2, Decl(0.js, 21, 5))
-
diff --git a/tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.errors.txt b/tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.errors.txt
index 05fecf03d30..9a9a7a12db9 100644
--- a/tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.errors.txt
+++ b/tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.errors.txt
@@ -1,15 +1,21 @@
 tests/cases/compiler/a.js(1,22): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/a.js(1,22): error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
 tests/cases/compiler/a.js(3,1): error TS2528: A module cannot have multiple default exports.
 tests/cases/compiler/a.js(3,16): error TS1109: Expression expected.
+tests/cases/compiler/a.js(3,20): error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
 
 
-==== tests/cases/compiler/a.js (3 errors) ====
+==== tests/cases/compiler/a.js (5 errors) ====
     export default class a {
                          ~
 !!! error TS2528: A module cannot have multiple default exports.
+                         ~
+!!! error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
     }
     export default var a = 10;
     ~~~~~~~~~~~~~~
 !!! error TS2528: A module cannot have multiple default exports.
                    ~~~
-!!! error TS1109: Expression expected.
\ No newline at end of file
+!!! error TS1109: Expression expected.
+                       ~
+!!! error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
\ No newline at end of file
diff --git a/tests/baselines/reference/jsFileCompilationBindStrictModeErrors.errors.txt b/tests/baselines/reference/jsFileCompilationBindStrictModeErrors.errors.txt
index d681cec3775..ed19b5c4a9b 100644
--- a/tests/baselines/reference/jsFileCompilationBindStrictModeErrors.errors.txt
+++ b/tests/baselines/reference/jsFileCompilationBindStrictModeErrors.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/compiler/a.js(5,5): error TS1117: An object literal cannot have multiple properties with the same name in strict mode.
+tests/cases/compiler/a.js(5,5): error TS2300: Duplicate identifier 'a'.
 tests/cases/compiler/a.js(7,5): error TS1212: Identifier expected. 'let' is a reserved word in strict mode.
 tests/cases/compiler/a.js(8,8): error TS1102: 'delete' cannot be called on an identifier in strict mode.
+tests/cases/compiler/a.js(8,8): error TS2703: The operand of a delete operator must be a property reference.
 tests/cases/compiler/a.js(10,10): error TS1100: Invalid use of 'eval' in strict mode.
 tests/cases/compiler/a.js(12,10): error TS1100: Invalid use of 'arguments' in strict mode.
 tests/cases/compiler/a.js(15,1): error TS1101: 'with' statements are not allowed in strict mode.
+tests/cases/compiler/a.js(15,1): error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
 tests/cases/compiler/b.js(3,7): error TS1210: Invalid use of 'eval'. Class definitions are automatically in strict mode.
 tests/cases/compiler/b.js(6,13): error TS1213: Identifier expected. 'let' is a reserved word in strict mode. Class definitions are automatically in strict mode.
 tests/cases/compiler/c.js(1,12): error TS1214: Identifier expected. 'let' is a reserved word in strict mode. Modules are automatically in strict mode.
@@ -12,7 +15,7 @@ tests/cases/compiler/d.js(2,9): error TS1121: Octal literals are not allowed in
 tests/cases/compiler/d.js(2,11): error TS1005: ',' expected.
 
 
-==== tests/cases/compiler/a.js (6 errors) ====
+==== tests/cases/compiler/a.js (9 errors) ====
     "use strict";
     var a = {
         a: "hello", // error
@@ -20,6 +23,8 @@ tests/cases/compiler/d.js(2,11): error TS1005: ',' expected.
         a: 10 // error
         ~
 !!! error TS1117: An object literal cannot have multiple properties with the same name in strict mode.
+        ~
+!!! error TS2300: Duplicate identifier 'a'.
     };
     var let = 10; // error
         ~~~
@@ -27,6 +32,8 @@ tests/cases/compiler/d.js(2,11): error TS1005: ',' expected.
     delete a; // error
            ~
 !!! error TS1102: 'delete' cannot be called on an identifier in strict mode.
+           ~
+!!! error TS2703: The operand of a delete operator must be a property reference.
     try {
     } catch (eval) { // error
              ~~~~
@@ -40,6 +47,8 @@ tests/cases/compiler/d.js(2,11): error TS1005: ',' expected.
     with (a) {
     ~~~~
 !!! error TS1101: 'with' statements are not allowed in strict mode.
+    ~~~~~~~~
+!!! error TS2410: The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.
         b = 10;
     }
     
diff --git a/tests/baselines/reference/jsdocReturnTag1.js b/tests/baselines/reference/jsdocReturnTag1.js
new file mode 100644
index 00000000000..5cb0dfedf87
--- /dev/null
+++ b/tests/baselines/reference/jsdocReturnTag1.js
@@ -0,0 +1,41 @@
+//// [returns.js]
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return 5;
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
+
+//// [dummy.js]
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return 5;
+}
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
diff --git a/tests/baselines/reference/jsdocReturnTag1.symbols b/tests/baselines/reference/jsdocReturnTag1.symbols
new file mode 100644
index 00000000000..5dd83a0b8eb
--- /dev/null
+++ b/tests/baselines/reference/jsdocReturnTag1.symbols
@@ -0,0 +1,27 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : Symbol(f, Decl(returns.js, 0, 0))
+
+    return 5;
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+>f1 : Symbol(f1, Decl(returns.js, 5, 1))
+
+    return 5;
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+>f2 : Symbol(f2, Decl(returns.js, 12, 1))
+
+    return 5 || "hello";
+}
diff --git a/tests/baselines/reference/jsdocReturnTag1.types b/tests/baselines/reference/jsdocReturnTag1.types
new file mode 100644
index 00000000000..d2a5891b29a
--- /dev/null
+++ b/tests/baselines/reference/jsdocReturnTag1.types
@@ -0,0 +1,32 @@
+=== tests/cases/conformance/jsdoc/returns.js ===
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+>f : () => string
+
+    return 5;
+>5 : 5
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+>f1 : () => string
+
+    return 5;
+>5 : 5
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+>f2 : () => string | number
+
+    return 5 || "hello";
+>5 || "hello" : 5 | "hello"
+>5 : 5
+>"hello" : "hello"
+}
diff --git a/tests/baselines/reference/jsdocTypeTag.js b/tests/baselines/reference/jsdocTypeTag.js
new file mode 100644
index 00000000000..ff92f0f0474
--- /dev/null
+++ b/tests/baselines/reference/jsdocTypeTag.js
@@ -0,0 +1,141 @@
+//// [tests/cases/conformance/jsdoc/jsdocTypeTag.ts] ////
+
+//// [a.js]
+/** @type {String} */
+var S;
+
+/** @type {string} */
+var s;
+
+/** @type {Number} */
+var N;
+
+/** @type {number} */
+var n;
+
+/** @type {Boolean} */
+var B;
+
+/** @type {boolean} */
+var b;
+
+/** @type {Void} */
+var V;
+
+/** @type {void} */
+var v;
+
+/** @type {Undefined} */
+var U;
+
+/** @type {undefined} */
+var u;
+
+/** @type {Null} */
+var Nl;
+
+/** @type {null} */
+var nl;
+
+/** @type {Array} */
+var A;
+
+/** @type {array} */
+var a;
+
+/** @type {Promise} */
+var P;
+
+/** @type {promise} */
+var p;
+
+/** @type {?number} */
+var nullable;
+
+/** @type {Object} */
+var Obj;
+
+/** @type {Function} */
+var Func;
+
+//// [b.ts]
+var S: string;
+var s: string;
+var N: number;
+var n: number
+var B: boolean;
+var b: boolean;
+var V :void;
+var v: void;
+var U: undefined;
+var u: undefined;
+var Nl: null;
+var nl: null;
+var A: any[];
+var a: any[];
+var P: Promise<any>;
+var p: Promise<any>;
+var nullable: number | null;
+var Obj: any;
+var Func: Function;
+
+
+//// [a.js]
+/** @type {String} */
+var S;
+/** @type {string} */
+var s;
+/** @type {Number} */
+var N;
+/** @type {number} */
+var n;
+/** @type {Boolean} */
+var B;
+/** @type {boolean} */
+var b;
+/** @type {Void} */
+var V;
+/** @type {void} */
+var v;
+/** @type {Undefined} */
+var U;
+/** @type {undefined} */
+var u;
+/** @type {Null} */
+var Nl;
+/** @type {null} */
+var nl;
+/** @type {Array} */
+var A;
+/** @type {array} */
+var a;
+/** @type {Promise} */
+var P;
+/** @type {promise} */
+var p;
+/** @type {?number} */
+var nullable;
+/** @type {Object} */
+var Obj;
+/** @type {Function} */
+var Func;
+//// [b.js]
+var S;
+var s;
+var N;
+var n;
+var B;
+var b;
+var V;
+var v;
+var U;
+var u;
+var Nl;
+var nl;
+var A;
+var a;
+var P;
+var p;
+var nullable;
+var Obj;
+var Func;
diff --git a/tests/baselines/reference/jsdocTypeTag.symbols b/tests/baselines/reference/jsdocTypeTag.symbols
new file mode 100644
index 00000000000..5931c1cfe53
--- /dev/null
+++ b/tests/baselines/reference/jsdocTypeTag.symbols
@@ -0,0 +1,138 @@
+=== tests/cases/conformance/jsdoc/a.js ===
+/** @type {String} */
+var S;
+>S : Symbol(S, Decl(a.js, 1, 3), Decl(b.ts, 0, 3))
+
+/** @type {string} */
+var s;
+>s : Symbol(s, Decl(a.js, 4, 3), Decl(b.ts, 1, 3))
+
+/** @type {Number} */
+var N;
+>N : Symbol(N, Decl(a.js, 7, 3), Decl(b.ts, 2, 3))
+
+/** @type {number} */
+var n;
+>n : Symbol(n, Decl(a.js, 10, 3), Decl(b.ts, 3, 3))
+
+/** @type {Boolean} */
+var B;
+>B : Symbol(B, Decl(a.js, 13, 3), Decl(b.ts, 4, 3))
+
+/** @type {boolean} */
+var b;
+>b : Symbol(b, Decl(a.js, 16, 3), Decl(b.ts, 5, 3))
+
+/** @type {Void} */
+var V;
+>V : Symbol(V, Decl(a.js, 19, 3), Decl(b.ts, 6, 3))
+
+/** @type {void} */
+var v;
+>v : Symbol(v, Decl(a.js, 22, 3), Decl(b.ts, 7, 3))
+
+/** @type {Undefined} */
+var U;
+>U : Symbol(U, Decl(a.js, 25, 3), Decl(b.ts, 8, 3))
+
+/** @type {undefined} */
+var u;
+>u : Symbol(u, Decl(a.js, 28, 3), Decl(b.ts, 9, 3))
+
+/** @type {Null} */
+var Nl;
+>Nl : Symbol(Nl, Decl(a.js, 31, 3), Decl(b.ts, 10, 3))
+
+/** @type {null} */
+var nl;
+>nl : Symbol(nl, Decl(a.js, 34, 3), Decl(b.ts, 11, 3))
+
+/** @type {Array} */
+var A;
+>A : Symbol(A, Decl(a.js, 37, 3), Decl(b.ts, 12, 3))
+
+/** @type {array} */
+var a;
+>a : Symbol(a, Decl(a.js, 40, 3), Decl(b.ts, 13, 3))
+
+/** @type {Promise} */
+var P;
+>P : Symbol(P, Decl(a.js, 43, 3), Decl(b.ts, 14, 3))
+
+/** @type {promise} */
+var p;
+>p : Symbol(p, Decl(a.js, 46, 3), Decl(b.ts, 15, 3))
+
+/** @type {?number} */
+var nullable;
+>nullable : Symbol(nullable, Decl(a.js, 49, 3), Decl(b.ts, 16, 3))
+
+/** @type {Object} */
+var Obj;
+>Obj : Symbol(Obj, Decl(a.js, 52, 3), Decl(b.ts, 17, 3))
+
+/** @type {Function} */
+var Func;
+>Func : Symbol(Func, Decl(a.js, 55, 3), Decl(b.ts, 18, 3))
+
+=== tests/cases/conformance/jsdoc/b.ts ===
+var S: string;
+>S : Symbol(S, Decl(a.js, 1, 3), Decl(b.ts, 0, 3))
+
+var s: string;
+>s : Symbol(s, Decl(a.js, 4, 3), Decl(b.ts, 1, 3))
+
+var N: number;
+>N : Symbol(N, Decl(a.js, 7, 3), Decl(b.ts, 2, 3))
+
+var n: number
+>n : Symbol(n, Decl(a.js, 10, 3), Decl(b.ts, 3, 3))
+
+var B: boolean;
+>B : Symbol(B, Decl(a.js, 13, 3), Decl(b.ts, 4, 3))
+
+var b: boolean;
+>b : Symbol(b, Decl(a.js, 16, 3), Decl(b.ts, 5, 3))
+
+var V :void;
+>V : Symbol(V, Decl(a.js, 19, 3), Decl(b.ts, 6, 3))
+
+var v: void;
+>v : Symbol(v, Decl(a.js, 22, 3), Decl(b.ts, 7, 3))
+
+var U: undefined;
+>U : Symbol(U, Decl(a.js, 25, 3), Decl(b.ts, 8, 3))
+
+var u: undefined;
+>u : Symbol(u, Decl(a.js, 28, 3), Decl(b.ts, 9, 3))
+
+var Nl: null;
+>Nl : Symbol(Nl, Decl(a.js, 31, 3), Decl(b.ts, 10, 3))
+
+var nl: null;
+>nl : Symbol(nl, Decl(a.js, 34, 3), Decl(b.ts, 11, 3))
+
+var A: any[];
+>A : Symbol(A, Decl(a.js, 37, 3), Decl(b.ts, 12, 3))
+
+var a: any[];
+>a : Symbol(a, Decl(a.js, 40, 3), Decl(b.ts, 13, 3))
+
+var P: Promise<any>;
+>P : Symbol(P, Decl(a.js, 43, 3), Decl(b.ts, 14, 3))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+
+var p: Promise<any>;
+>p : Symbol(p, Decl(a.js, 46, 3), Decl(b.ts, 15, 3))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
+
+var nullable: number | null;
+>nullable : Symbol(nullable, Decl(a.js, 49, 3), Decl(b.ts, 16, 3))
+
+var Obj: any;
+>Obj : Symbol(Obj, Decl(a.js, 52, 3), Decl(b.ts, 17, 3))
+
+var Func: Function;
+>Func : Symbol(Func, Decl(a.js, 55, 3), Decl(b.ts, 18, 3))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/jsdocTypeTag.types b/tests/baselines/reference/jsdocTypeTag.types
new file mode 100644
index 00000000000..f3e7dfad634
--- /dev/null
+++ b/tests/baselines/reference/jsdocTypeTag.types
@@ -0,0 +1,141 @@
+=== tests/cases/conformance/jsdoc/a.js ===
+/** @type {String} */
+var S;
+>S : string
+
+/** @type {string} */
+var s;
+>s : string
+
+/** @type {Number} */
+var N;
+>N : number
+
+/** @type {number} */
+var n;
+>n : number
+
+/** @type {Boolean} */
+var B;
+>B : boolean
+
+/** @type {boolean} */
+var b;
+>b : boolean
+
+/** @type {Void} */
+var V;
+>V : void
+
+/** @type {void} */
+var v;
+>v : void
+
+/** @type {Undefined} */
+var U;
+>U : undefined
+
+/** @type {undefined} */
+var u;
+>u : undefined
+
+/** @type {Null} */
+var Nl;
+>Nl : null
+
+/** @type {null} */
+var nl;
+>nl : null
+
+/** @type {Array} */
+var A;
+>A : any[]
+
+/** @type {array} */
+var a;
+>a : any[]
+
+/** @type {Promise} */
+var P;
+>P : Promise<any>
+
+/** @type {promise} */
+var p;
+>p : Promise<any>
+
+/** @type {?number} */
+var nullable;
+>nullable : number | null
+
+/** @type {Object} */
+var Obj;
+>Obj : any
+
+/** @type {Function} */
+var Func;
+>Func : Function
+
+=== tests/cases/conformance/jsdoc/b.ts ===
+var S: string;
+>S : string
+
+var s: string;
+>s : string
+
+var N: number;
+>N : number
+
+var n: number
+>n : number
+
+var B: boolean;
+>B : boolean
+
+var b: boolean;
+>b : boolean
+
+var V :void;
+>V : void
+
+var v: void;
+>v : void
+
+var U: undefined;
+>U : undefined
+
+var u: undefined;
+>u : undefined
+
+var Nl: null;
+>Nl : null
+>null : null
+
+var nl: null;
+>nl : null
+>null : null
+
+var A: any[];
+>A : any[]
+
+var a: any[];
+>a : any[]
+
+var P: Promise<any>;
+>P : Promise<any>
+>Promise : Promise<T>
+
+var p: Promise<any>;
+>p : Promise<any>
+>Promise : Promise<T>
+
+var nullable: number | null;
+>nullable : number | null
+>null : null
+
+var Obj: any;
+>Obj : any
+
+var Func: Function;
+>Func : Function
+>Function : Function
+
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.symbols b/tests/baselines/reference/keyofAndIndexedAccess.symbols
index 65cc44fe84b..461652fb725 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.symbols
+++ b/tests/baselines/reference/keyofAndIndexedAccess.symbols
@@ -453,9 +453,9 @@ function pluck<T, K extends keyof T>(array: T[], key: K) {
 >K : Symbol(K, Decl(keyofAndIndexedAccess.ts, 131, 17))
 
     return array.map(x => x[key]);
->array.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>array.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >array : Symbol(array, Decl(keyofAndIndexedAccess.ts, 131, 37))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21))
 >x : Symbol(x, Decl(keyofAndIndexedAccess.ts, 132, 21))
 >key : Symbol(key, Decl(keyofAndIndexedAccess.ts, 131, 48))
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index a9698a47bd2..671289527aa 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: 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.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >array : T[]
->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]
+>map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>x => x[key] : (x: T) => T[K]
 >x : T
 >x[key] : T[K]
 >x : T
diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js
index 565988bfd73..3298190fdee 100644
--- a/tests/baselines/reference/mapOnTupleTypes01.js
+++ b/tests/baselines/reference/mapOnTupleTypes01.js
@@ -72,10 +72,10 @@ exports.h = numNumNumNumNum.map(function (n) { return n * n; });
 //// [mapOnTupleTypes01.d.ts]
 export declare let mapOnLooseArrayLiteral: number[];
 export declare let a: number[];
-export declare let b: [number, number];
-export declare let c: [number, number];
-export declare let d: [string | number, string | number];
-export declare let e: [number, number, number];
-export declare let f: [number, number, number, number];
-export declare let g: [number, number, number, number, number];
-export declare let h: [number, number, number, number, number];
+export declare let b: number[];
+export declare let c: number[];
+export declare let d: (string | number)[];
+export declare let e: number[];
+export declare let f: number[];
+export declare let g: number[];
+export declare let h: number[];
diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols
index 687439199fe..ba21161decc 100644
--- a/tests/baselines/reference/mapOnTupleTypes01.symbols
+++ b/tests/baselines/reference/mapOnTupleTypes01.symbols
@@ -1,8 +1,8 @@
 === tests/cases/compiler/mapOnTupleTypes01.ts ===
 export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
 >mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 0, 10))
->[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 0, 53))
@@ -14,9 +14,9 @@ let numTuple: [number] = [1];
 
 export let a = numTuple.map(x => x * x);
 >a : Symbol(a, Decl(mapOnTupleTypes01.ts, 5, 10))
->numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 4, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28))
 >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28))
 >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 5, 28))
@@ -34,18 +34,18 @@ let numStr: [number, string] = [    100, "hello"];
 
 export let b = numNum.map(n => n * n);
 >b : Symbol(b, Decl(mapOnTupleTypes01.ts, 13, 10))
->numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 9, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 13, 26))
 
 export let c = strStr.map(s => s.charCodeAt(0));
 >c : Symbol(c, Decl(mapOnTupleTypes01.ts, 14, 10))
->strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 10, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26))
 >s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(mapOnTupleTypes01.ts, 14, 26))
@@ -53,9 +53,9 @@ export let c = strStr.map(s => s.charCodeAt(0));
 
 export let d = numStr.map(x => x);
 >d : Symbol(d, Decl(mapOnTupleTypes01.ts, 15, 10))
->numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 11, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26))
 >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 15, 26))
 
@@ -66,9 +66,9 @@ let numNumNum: [number, number, number] = [1, 2, 3];
 
 export let e = numNumNum.map(n => n * n);
 >e : Symbol(e, Decl(mapOnTupleTypes01.ts, 21, 10))
->numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 19, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 21, 29))
@@ -80,9 +80,9 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
 
 export let f = numNumNumNum.map(n => n * n);
 >f : Symbol(f, Decl(mapOnTupleTypes01.ts, 27, 10))
->numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 25, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 27, 32))
@@ -94,9 +94,9 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
 
 export let g = numNumNumNumNum.map(n => n * n);
 >g : Symbol(g, Decl(mapOnTupleTypes01.ts, 33, 10))
->numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 33, 35))
@@ -109,9 +109,9 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2
 
 export let h = numNumNumNumNum.map(n => n * n);
 >h : Symbol(h, Decl(mapOnTupleTypes01.ts, 40, 10))
->numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 31, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35))
 >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 40, 35))
diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types
index 72b6a6dbae1..adb8a2e191c 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: 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].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3, 4] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
 >4 : 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[]; }
->n => n * n : (this: void, n: number) => number
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (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: 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.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numTuple : [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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>x => x * x : (x: number) => number
 >x : number
 >x * x : number
 >x : number
@@ -55,24 +55,24 @@ let numStr: [number, string] = [    100, "hello"];
 >"hello" : "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: 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[]; }
+>b : number[]
+>numNum.map(n => n * n) : number[]
+>numNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNum : [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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
 >n : number
 >n * n : number
 >n : number
 >n : number
 
 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: 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[]; }
+>c : number[]
+>strStr.map(s => s.charCodeAt(0)) : number[]
+>strStr.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >strStr : [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.charCodeAt(0) : (this: void, s: string) => number
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s => s.charCodeAt(0) : (s: string) => number
 >s : string
 >s.charCodeAt(0) : number
 >s.charCodeAt : (index: number) => number
@@ -81,12 +81,12 @@ export let c = strStr.map(s => s.charCodeAt(0));
 >0 : 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: 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[]; }
+>d : (string | number)[]
+>numStr.map(x => x) : (string | number)[]
+>numStr.map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
 >numStr : [number, string]
->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
+>map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
+>x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
 
@@ -100,12 +100,12 @@ let numNumNum: [number, number, number] = [1, 2, 3];
 >3 : 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: 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[]; }
+>e : number[]
+>numNumNum.map(n => n * n) : number[]
+>numNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNum : [number, 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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -122,12 +122,12 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
 >4 : 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: 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[]; }
+>f : number[]
+>numNumNumNum.map(n => n * n) : number[]
+>numNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNum : [number, number, 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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -145,12 +145,12 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
 >5 : 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: 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[]; }
+>g : number[]
+>numNumNumNumNum.map(n => n * n) : number[]
+>numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNumNum : [number, number, number, 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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
 >n : number
 >n * n : number
 >n : number
@@ -170,12 +170,12 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2
 >6 : 6
 
 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: 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[]; }
+>h : number[]
+>numNumNumNumNum.map(n => n * n) : number[]
+>numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNumNum : [number, number, number, 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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
 >n : number
 >n * n : number
 >n : number
diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js
index 2fd4daab16b..8e0a8720a18 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.js
+++ b/tests/baselines/reference/mapOnTupleTypes02.js
@@ -16,4 +16,4 @@ exports.increment = increment;
 
 //// [mapOnTupleTypes02.d.ts]
 export declare type Point = [number, number];
-export declare function increment(point: Point): [number, number];
+export declare function increment(point: Point): number[];
diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols
index b96b3be3134..e0f37faf8ea 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.symbols
+++ b/tests/baselines/reference/mapOnTupleTypes02.symbols
@@ -8,9 +8,9 @@ export function increment(point: Point) {
 >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0))
 
   return point.map(d => d + 1);
->point.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>point.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >point : Symbol(point, Decl(mapOnTupleTypes02.ts, 2, 26))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19))
 >d : Symbol(d, Decl(mapOnTupleTypes02.ts, 3, 19))
 }
diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types
index 72fbbf31b11..9a0ccef0285 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.types
+++ b/tests/baselines/reference/mapOnTupleTypes02.types
@@ -3,16 +3,16 @@ export type Point = [number, number];
 >Point : [number, number]
 
 export function increment(point: Point) {
->increment : (point: [number, number]) => [number, number]
+>increment : (point: [number, number]) => number[]
 >point : [number, number]
 >Point : [number, number]
 
   return point.map(d => d + 1);
->point.map(d => d + 1) : [number, number]
->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.map(d => d + 1) : number[]
+>point.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >point : [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
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>d => d + 1 : (d: number) => number
 >d : number
 >d + 1 : number
 >d : number
diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols
index 6fa6bb1b59f..50bdd9981e2 100644
--- a/tests/baselines/reference/nestedSelf.symbols
+++ b/tests/baselines/reference/nestedSelf.symbols
@@ -10,8 +10,8 @@ module M {
 
    public foo() { [1,2,3].map((x) => { return this.n * x; })}
 >foo : Symbol(C.foo, Decl(nestedSelf.ts, 2, 17))
->[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(nestedSelf.ts, 3, 31))
 >this.n : Symbol(C.n, Decl(nestedSelf.ts, 1, 17))
 >this : Symbol(C, Decl(nestedSelf.ts, 0, 10))
diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types
index 819a76dc380..9fb4b0bd65d 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: 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].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1,2,3] : number[]
 >1 : 1
 >2 : 2
 >3 : 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[]; }
->(x) => { return this.n * x; } : (this: void, x: number) => number
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>(x) => { return this.n * x; } : (x: number) => number
 >x : number
 >this.n * x : number
 >this.n : number
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
index d76ee3019b3..db4148efdf9 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
@@ -3,9 +3,9 @@ var regexMatchList = ['', ''];
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3))
 
 regexMatchList.forEach(match => ''.replace(match, ''));
->regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 0, 3))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 23))
 >''.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
index cee8cc24e44..93b9020c78c 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: 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.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >regexMatchList : 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
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>match => ''.replace(match, '') : (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/nonPrimitiveUnionIntersection.errors.txt b/tests/baselines/reference/nonPrimitiveUnionIntersection.errors.txt
index 5fb1e89c2e3..5aad982dc20 100644
--- a/tests/baselines/reference/nonPrimitiveUnionIntersection.errors.txt
+++ b/tests/baselines/reference/nonPrimitiveUnionIntersection.errors.txt
@@ -1,18 +1,32 @@
 tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts(1,5): error TS2322: Type '""' is not assignable to type 'object & string'.
   Type '""' is not assignable to type 'object'.
-tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts(3,1): error TS2322: Type 'string' is not assignable to type 'object & string'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts(3,5): error TS2322: Type '123' is not assignable to type 'object & {}'.
+  Type '123' is not assignable to type 'object'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts(4,1): error TS2322: Type 'string' is not assignable to type 'object & string'.
   Type 'string' is not assignable to type 'object'.
+tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts(8,38): error TS2322: Type '{ bar: string; }' is not assignable to type 'object & { err: string; }'.
+  Object literal may only specify known properties, and 'bar' does not exist in type 'object & { err: string; }'.
 
 
-==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts (2 errors) ====
+==== tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts (4 errors) ====
     var a: object & string = ""; // error
         ~
 !!! error TS2322: Type '""' is not assignable to type 'object & string'.
 !!! error TS2322:   Type '""' is not assignable to type 'object'.
     var b: object | string = ""; // ok
+    var c: object & {} = 123; // error
+        ~
+!!! error TS2322: Type '123' is not assignable to type 'object & {}'.
+!!! error TS2322:   Type '123' is not assignable to type 'object'.
     a = b; // error
     ~
 !!! error TS2322: Type 'string' is not assignable to type 'object & string'.
 !!! error TS2322:   Type 'string' is not assignable to type 'object'.
     b = a; // ok
+    
+    const foo: object & {} = {bar: 'bar'}; // ok
+    const bar: object & {err: string} = {bar: 'bar'}; // error
+                                         ~~~~~~~~~~
+!!! error TS2322: Type '{ bar: string; }' is not assignable to type 'object & { err: string; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'bar' does not exist in type 'object & { err: string; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/nonPrimitiveUnionIntersection.js b/tests/baselines/reference/nonPrimitiveUnionIntersection.js
index 7f4b46c42ed..771024f15e6 100644
--- a/tests/baselines/reference/nonPrimitiveUnionIntersection.js
+++ b/tests/baselines/reference/nonPrimitiveUnionIntersection.js
@@ -1,17 +1,29 @@
 //// [nonPrimitiveUnionIntersection.ts]
 var a: object & string = ""; // error
 var b: object | string = ""; // ok
+var c: object & {} = 123; // error
 a = b; // error
 b = a; // ok
+
+const foo: object & {} = {bar: 'bar'}; // ok
+const bar: object & {err: string} = {bar: 'bar'}; // error
 
 
 //// [nonPrimitiveUnionIntersection.js]
 var a = ""; // error
 var b = ""; // ok
+var c = 123; // error
 a = b; // error
 b = a; // ok
+var foo = { bar: 'bar' }; // ok
+var bar = { bar: 'bar' }; // error
 
 
 //// [nonPrimitiveUnionIntersection.d.ts]
 declare var a: object & string;
 declare var b: object | string;
+declare var c: object & {};
+declare const foo: object & {};
+declare const bar: object & {
+    err: string;
+};
diff --git a/tests/baselines/reference/objectRestForOf.symbols b/tests/baselines/reference/objectRestForOf.symbols
index d10b0de4d0e..2d5d6a2bb2d 100644
--- a/tests/baselines/reference/objectRestForOf.symbols
+++ b/tests/baselines/reference/objectRestForOf.symbols
@@ -32,9 +32,9 @@ for ({ x: xx, ...rrestOff } of array ) {
 }
 for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 >norest : Symbol(norest, Decl(objectRestForOf.ts, 9, 10))
->array.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>array.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >array : Symbol(array, Decl(objectRestForOf.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >a : Symbol(a, Decl(objectRestForOf.ts, 9, 31))
 >a : Symbol(a, Decl(objectRestForOf.ts, 9, 31))
 >x : Symbol(x, Decl(objectRestForOf.ts, 9, 44))
diff --git a/tests/baselines/reference/objectRestForOf.types b/tests/baselines/reference/objectRestForOf.types
index ba6febd69c2..43d42a045e1 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: 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.map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => 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: 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; }
+>map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
+>a => ({ ...a, x: 'a string' }) : (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/reexportedMissingAlias.errors.txt b/tests/baselines/reference/reexportedMissingAlias.errors.txt
new file mode 100644
index 00000000000..c22bf2da9d0
--- /dev/null
+++ b/tests/baselines/reference/reexportedMissingAlias.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/second.d.ts(2,27): error TS2304: Cannot find name 'CompletelyMissing'.
+tests/cases/compiler/second.d.ts(2,27): error TS2503: Cannot find namespace 'CompletelyMissing'.
+
+
+==== tests/cases/compiler/second.d.ts (2 errors) ====
+    // Fixes #15094
+    export import Component = CompletelyMissing;
+                              ~~~~~~~~~~~~~~~~~
+!!! error TS2304: Cannot find name 'CompletelyMissing'.
+                              ~~~~~~~~~~~~~~~~~
+!!! error TS2503: Cannot find namespace 'CompletelyMissing'.
+==== tests/cases/compiler/first.d.ts (0 errors) ====
+    import * as Second from './second';
+    export = Second;
+==== tests/cases/compiler/crash.ts (0 errors) ====
+    import { Component } from './first';
+    class C extends Component { }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/reexportedMissingAlias.js b/tests/baselines/reference/reexportedMissingAlias.js
new file mode 100644
index 00000000000..792ea3eb5c2
--- /dev/null
+++ b/tests/baselines/reference/reexportedMissingAlias.js
@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/reexportedMissingAlias.ts] ////
+
+//// [second.d.ts]
+// Fixes #15094
+export import Component = CompletelyMissing;
+//// [first.d.ts]
+import * as Second from './second';
+export = Second;
+//// [crash.ts]
+import { Component } from './first';
+class C extends Component { }
+
+
+//// [crash.js]
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+var first_1 = require("./first");
+var C = (function (_super) {
+    __extends(C, _super);
+    function C() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return C;
+}(first_1.Component));
diff --git a/tests/baselines/reference/returns.js b/tests/baselines/reference/returns.js
deleted file mode 100644
index 67390dea72a..00000000000
--- a/tests/baselines/reference/returns.js
+++ /dev/null
@@ -1,16 +0,0 @@
-//// [returns.js]
-/**
- * @returns {string} This comment is not currently exposed
- */
-function f() {
-    return "";
-}
-
-
-//// [dummy.js]
-/**
- * @returns {string} This comment is not currently exposed
- */
-function f() {
-    return "";
-}
diff --git a/tests/baselines/reference/returns.symbols b/tests/baselines/reference/returns.symbols
deleted file mode 100644
index e0f0d4dac96..00000000000
--- a/tests/baselines/reference/returns.symbols
+++ /dev/null
@@ -1,10 +0,0 @@
-=== tests/cases/conformance/jsdoc/returns.js ===
-/**
- * @returns {string} This comment is not currently exposed
- */
-function f() {
->f : Symbol(f, Decl(returns.js, 0, 0))
-
-    return "";
-}
-
diff --git a/tests/baselines/reference/returns.types b/tests/baselines/reference/returns.types
deleted file mode 100644
index c85bc7272f8..00000000000
--- a/tests/baselines/reference/returns.types
+++ /dev/null
@@ -1,11 +0,0 @@
-=== tests/cases/conformance/jsdoc/returns.js ===
-/**
- * @returns {string} This comment is not currently exposed
- */
-function f() {
->f : () => string
-
-    return "";
->"" : ""
-}
-
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
index edb2c362fc2..49528257830 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts ===
 [].map(() => [].map(p => ({ X: p })));
->[].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->[].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
index fa6f2b27fbe..417a51ac4b8 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: 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 : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[] : undefined[]
->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 : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >() => [].map(p => ({ X: p })) : () => { X: any; }[]
 >[].map(p => ({ X: p })) : { 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[]; }
+>[].map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[] : undefined[]
->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; }
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>p => ({ X: p }) : (p: any) => { X: any; }
 >p : any
 >({ X: p }) : { X: any; }
 >{ X: p } : { X: any; }
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
index febbd451db7..cf2a3aa41cd 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
@@ -22,9 +22,9 @@ function foo() {
 >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7))
 
     series2.map(seriesExtent);
->series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 11, 7))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 9, 7))
 
     return null;
@@ -33,11 +33,11 @@ function foo() {
 
 var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 18, 3))
->series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19))
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 4, 3))
 >data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 0, 19))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 18, 50))
 
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
index b7dea45c6eb..6bf7c299a1f 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: 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.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >series2 : 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[]; }
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => 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: 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.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >series.data : string[]
 >series : Series
 >data : 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
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>function (d: string) { return d; } : (d: string) => string
 >d : string
 >d : string
 
diff --git a/tests/baselines/reference/subtypingWithObjectMembers5.errors.txt b/tests/baselines/reference/subtypingWithObjectMembers5.errors.txt
index 7fd025721ec..022f9138108 100644
--- a/tests/baselines/reference/subtypingWithObjectMembers5.errors.txt
+++ b/tests/baselines/reference/subtypingWithObjectMembers5.errors.txt
@@ -4,9 +4,12 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Property '1' is missing in type 'B2'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts(32,11): error TS2420: Class 'B3' incorrectly implements interface 'A3'.
   Property ''1'' is missing in type 'B3'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts(43,11): error TS2559: Type 'B' has no properties in common with type 'A'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts(51,11): error TS2559: Type 'B2' has no properties in common with type 'A2'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts(59,11): error TS2559: Type 'B3' has no properties in common with type 'A3'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts (3 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts (6 errors) ====
     interface Base {
         foo: string;
     }
@@ -59,7 +62,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         }
     
         class B implements A {
-            fooo: Derived; // ok
+              ~
+!!! error TS2559: Type 'B' has no properties in common with type 'A'.
+            fooo: Derived; // weak type error
         }
     
         interface A2 {
@@ -67,7 +72,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         }
     
         class B2 implements A2 {
-            2: Derived; // ok
+              ~~
+!!! error TS2559: Type 'B2' has no properties in common with type 'A2'.
+            2: Derived; // weak type error
         }
     
         interface A3 {
@@ -75,6 +82,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
         }
     
         class B3 implements A3 {
-            '1.0': Derived; // ok
+              ~~
+!!! error TS2559: Type 'B3' has no properties in common with type 'A3'.
+            '1.0': Derived; // weak type error
         }
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/subtypingWithObjectMembers5.js b/tests/baselines/reference/subtypingWithObjectMembers5.js
index f01a603f563..4a0ac276594 100644
--- a/tests/baselines/reference/subtypingWithObjectMembers5.js
+++ b/tests/baselines/reference/subtypingWithObjectMembers5.js
@@ -42,7 +42,7 @@ module Optional {
     }
 
     class B implements A {
-        fooo: Derived; // ok
+        fooo: Derived; // weak type error
     }
 
     interface A2 {
@@ -50,7 +50,7 @@ module Optional {
     }
 
     class B2 implements A2 {
-        2: Derived; // ok
+        2: Derived; // weak type error
     }
 
     interface A3 {
@@ -58,9 +58,10 @@ module Optional {
     }
 
     class B3 implements A3 {
-        '1.0': Derived; // ok
+        '1.0': Derived; // weak type error
     }
-}
+}
+
 
 //// [subtypingWithObjectMembers5.js]
 // N and M have the same name, same accessibility, same optionality, and N is a subtype of M
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types b/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types
index 7f93418506f..9a61726dddc 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality3.types
@@ -69,8 +69,8 @@ var b: { Foo2: Derived; }
 >Derived : Derived
 
 var r = true ? a : b; // ok
->r : { Foo?: Base; }
->true ? a : b : { Foo?: Base; }
+>r : { Foo?: Base; } | { Foo2: Derived; }
+>true ? a : b : { Foo?: Base; } | { Foo2: Derived; }
 >true : true
 >a : { Foo?: Base; }
 >b : { Foo2: Derived; }
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types b/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types
index d1d00e8e1bc..056173dd97b 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality4.types
@@ -69,8 +69,8 @@ var b: { Foo2?: Derived; }
 >Derived : Derived
 
 var r = true ? a : b; // ok
->r : { Foo2?: Derived; }
->true ? a : b : { Foo2?: Derived; }
+>r : { Foo: Base; } | { Foo2?: Derived; }
+>true ? a : b : { Foo: Base; } | { Foo2?: Derived; }
 >true : true
 >a : { Foo: Base; }
 >b : { Foo2?: Derived; }
diff --git a/tests/baselines/reference/targetTypeArgs.symbols b/tests/baselines/reference/targetTypeArgs.symbols
index d7c40a6a609..b0d825ddd50 100644
--- a/tests/baselines/reference/targetTypeArgs.symbols
+++ b/tests/baselines/reference/targetTypeArgs.symbols
@@ -14,44 +14,44 @@ foo(function(x) { x });
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 
 [1].forEach(function(v,i,a) { v });
->[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 6, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 6, 25))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 
 ["hello"].every(function(v,i,a) {return true;});
->["hello"].every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["hello"].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 7, 25))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 7, 27))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 7, 29))
 
 [1].every(function(v,i,a) {return true;});
->[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 8, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 8, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 8, 23))
 
 [1].every(function(v,i,a) {return true;});
->[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 9, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 9, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 9, 23))
 
 ["s"].every(function(v,i,a) {return true;});
->["s"].every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->every : Symbol(Array.every, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["s"].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 10, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 10, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 10, 25))
 
 ["s"].forEach(function(v,i,a) { v });
->["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 11, 23))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 11, 25))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 11, 27))
diff --git a/tests/baselines/reference/targetTypeArgs.types b/tests/baselines/reference/targetTypeArgs.types
index ae09b5185a9..84985316aa2 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: 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].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >[1] : number[]
 >1 : 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; }
->function(v,i,a) { v } : (this: void, v: number, i: number, a: number[]) => void
+>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>function(v,i,a) { v } : (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: 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"].every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >["hello"] : string[]
 >"hello" : "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; }
->function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true
+>every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function(v,i,a) {return true;} : (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: 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].every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >[1] : number[]
 >1 : 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; }
->function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true
+>every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>function(v,i,a) {return true;} : (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: 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].every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >[1] : number[]
 >1 : 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; }
->function(v,i,a) {return true;} : (this: void, v: number, i: number, a: number[]) => true
+>every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>function(v,i,a) {return true;} : (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: 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"].every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >["s"] : string[]
 >"s" : "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; }
->function(v,i,a) {return true;} : (this: void, v: string, i: number, a: string[]) => true
+>every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function(v,i,a) {return true;} : (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: 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"].forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >["s"] : string[]
 >"s" : "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; }
->function(v,i,a) { v } : (this: void, v: string, i: number, a: string[]) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function(v,i,a) { v } : (v: string, i: number, a: string[]) => void
 >v : string
 >i : number
 >a : string[]
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
index d7903e3328a..6df8d8ac2ad 100644
--- a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
@@ -9,9 +9,9 @@ function suggest(){
 >result : Symbol(result, Decl(targetTypeObjectLiteralToAny.ts, 2, 4))
 					
 	TypeScriptKeywords.forEach(function(keyword) {						
->TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >TypeScriptKeywords : Symbol(TypeScriptKeywords, Decl(targetTypeObjectLiteralToAny.ts, 1, 4))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 
 		result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.types b/tests/baselines/reference/targetTypeObjectLiteralToAny.types
index b8802638728..1dd81b33603 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: 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.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >TypeScriptKeywords : 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; }
->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
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : (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/thisExpressionInCallExpressionWithTypeArguments.errors.txt b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.errors.txt
index 5288875b0ce..1dac3478c63 100644
--- a/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.errors.txt
+++ b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/thisExpressionInCallExpressionWithTypeArguments.ts(2,20): error TS2554: Expected 1-2 arguments, but got 1.
+tests/cases/compiler/thisExpressionInCallExpressionWithTypeArguments.ts(2,20): error TS2558: Expected 1 type arguments, but got 2.
 
 
 ==== tests/cases/compiler/thisExpressionInCallExpressionWithTypeArguments.ts (1 errors) ====
     class C {
         public foo() { [1,2,3].map<any,any>((x) => { return this; })}
                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2554: Expected 1-2 arguments, but got 1.
+!!! error TS2558: Expected 1 type arguments, but got 2.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.symbols b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.symbols
new file mode 100644
index 00000000000..c7f2b7c78a7
--- /dev/null
+++ b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/compiler/thisExpressionInCallExpressionWithTypeArguments.ts ===
+class C {
+>C : Symbol(C, Decl(thisExpressionInCallExpressionWithTypeArguments.ts, 0, 0))
+
+    public foo() { [1,2,3].map<any,any>((x) => { return this; })}
+>foo : Symbol(C.foo, Decl(thisExpressionInCallExpressionWithTypeArguments.ts, 0, 9))
+>[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(thisExpressionInCallExpressionWithTypeArguments.ts, 1, 41))
+>this : Symbol(C, Decl(thisExpressionInCallExpressionWithTypeArguments.ts, 0, 0))
+}
+
diff --git a/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types
new file mode 100644
index 00000000000..91b9c8bb74a
--- /dev/null
+++ b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types
@@ -0,0 +1,18 @@
+=== tests/cases/compiler/thisExpressionInCallExpressionWithTypeArguments.ts ===
+class C {
+>C : C
+
+    public foo() { [1,2,3].map<any,any>((x) => { return this; })}
+>foo : () => void
+>[1,2,3].map<any,any>((x) => { return this; }) : any[]
+>[1,2,3].map : <U, Z = void>(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, Z = void>(callbackfn: (this: Z, value: number, index: number, array: number[]) => U, thisArg?: Z) => U[]
+>(x) => { return this; } : (this: any, x: number) => this
+>x : number
+>this : this
+}
+
diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt
deleted file mode 100644
index 817478aa68e..00000000000
--- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.errors.txt
+++ /dev/null
@@ -1,409 +0,0 @@
-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/thisTypeInNativeThisAssignableMethods.symbols b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols
index bf1e8c8d1b5..2099b98c8b5 100644
--- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols
+++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.symbols
@@ -20,17 +20,12 @@ class A {
 >options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9))
         }
         options.forEach(function (item) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 3, 15))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 7, 34))
 
             this.options.push(item);
->this.options.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->this.options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(A.options, Decl(thisTypeInNativeThisAssignableMethods.ts, 0, 9))
->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >item : Symbol(item, Decl(thisTypeInNativeThisAssignableMethods.ts, 7, 34))
 
         }, this);
@@ -49,41 +44,38 @@ class A {
 >Array : Symbol(Array, Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 
         options.forEach(function () {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 
             undefinedArr.push(this);
 >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
 
         }); // case1
         options.forEach(function () {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 
             undefinedArr.push(this);
 >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
 
         }, undefined); // case2
 >undefined : Symbol(undefined)
 
         options.forEach(function () {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 13, 18))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 
             undefinedArr.push(this);
 >undefinedArr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
 >undefinedArr : Symbol(undefinedArr, Decl(thisTypeInNativeThisAssignableMethods.ts, 14, 13))
 >push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
 
         }, null); // case3
 
@@ -171,91 +163,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 49, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 53, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 58, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 62, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 36, 9))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 37, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 66, 36))
 
         }, thisObject);
@@ -354,91 +328,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 94, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 98, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 103, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 107, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 81, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 82, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 111, 36))
 
         }, thisObject);
@@ -494,91 +450,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 129, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 133, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 138, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 142, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 116, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 117, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 146, 36))
 
         }, thisObject);
@@ -634,91 +572,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 164, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 168, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 173, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 177, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 151, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 152, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 181, 36))
 
         }, thisObject);
@@ -774,91 +694,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 199, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 203, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 208, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 212, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 186, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 187, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 216, 36))
 
         }, thisObject);
@@ -914,91 +816,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 234, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 238, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 243, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 247, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 221, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 222, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 251, 36))
 
         }, thisObject);
@@ -1054,91 +938,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 269, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 273, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 278, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 282, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 256, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 257, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 286, 36))
 
         }, thisObject);
@@ -1194,91 +1060,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 304, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 308, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 313, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 317, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 291, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 292, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 321, 36))
 
         }, thisObject);
@@ -1334,91 +1182,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 339, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 343, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 348, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 352, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 326, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 327, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 356, 36))
 
         }, thisObject);
@@ -1474,91 +1304,73 @@ class A {
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13))
 
         options.forEach(function (val, index) {
->options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10))
->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 34))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 38))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 34))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 374, 38))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13))
 
         options.map(function (val, index) {
->options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10))
->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 30))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34))
 
             if (val === this.options[index])
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 30))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34))
 
                 return this.options[index];
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 378, 34))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13))
 
         options.some(function (val, index) {
->options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10))
->some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 31))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 35))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 31))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 383, 35))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13))
 
         options.filter(function (val, index) {
->options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10))
->filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>filter : Symbol(Array.filter, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 33))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 37))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 33))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 387, 37))
 
         }, thisObject);
 >thisObject : Symbol(thisObject, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 13))
 
         options.every(function (val, index) {
->options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>options.every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 361, 10))
->every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.es5.d.ts, --, --))
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 32))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 36))
 
             return val === this.options[index];
 >val : Symbol(val, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 32))
->this.options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
->this : Symbol(this, Decl(lib.es5.d.ts, --, --))
->options : Symbol(options, Decl(thisTypeInNativeThisAssignableMethods.ts, 362, 28))
 >index : Symbol(index, Decl(thisTypeInNativeThisAssignableMethods.ts, 391, 36))
 
         }, thisObject);
diff --git a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types
index d2ec6344af0..fecae87d4b1 100644
--- a/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types
+++ b/tests/baselines/reference/thisTypeInNativeThisAssignableMethods.types
@@ -24,19 +24,19 @@ class A {
         }
         options.forEach(function (item) {
 >options.forEach(function (item) {            this.options.push(item);        }, this) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 (item) {            this.options.push(item);        } : (this: this, item: string) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function (item) {            this.options.push(item);        } : (item: string) => void
 >item : string
 
             this.options.push(item);
->this.options.push(item) : number
->this.options.push : (...items: string[]) => number
->this.options : string[]
->this : this
->options : string[]
->push : (...items: string[]) => number
+>this.options.push(item) : any
+>this.options.push : any
+>this.options : any
+>this : any
+>options : any
+>push : any
 >item : string
 
         }, this);
@@ -57,49 +57,49 @@ class A {
 
         options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 () {            undefinedArr.push(this);        } : (this: undefined) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function () {            undefinedArr.push(this);        } : () => void
 
             undefinedArr.push(this);
 >undefinedArr.push(this) : number
 >undefinedArr.push : (...items: undefined[]) => number
 >undefinedArr : undefined[]
 >push : (...items: undefined[]) => number
->this : undefined
+>this : any
 
         }); // case1
         options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }, undefined) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 () {            undefinedArr.push(this);        } : (this: undefined) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function () {            undefinedArr.push(this);        } : () => void
 
             undefinedArr.push(this);
 >undefinedArr.push(this) : number
 >undefinedArr.push : (...items: undefined[]) => number
 >undefinedArr : undefined[]
 >push : (...items: undefined[]) => number
->this : undefined
+>this : any
 
         }, undefined); // case2
 >undefined : undefined
 
         options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }, null) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 () {            undefinedArr.push(this);        } : (this: undefined) => void
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function () {            undefinedArr.push(this);        } : () => void
 
             undefinedArr.push(this);
 >undefinedArr.push(this) : number
 >undefinedArr.push : (...items: undefined[]) => number
 >undefinedArr : undefined[]
 >push : (...items: undefined[]) => number
->this : undefined
+>this : any
 
         }, null); // case3
 >null : null
@@ -112,17 +112,17 @@ class A {
 
         Array.from(arrLike, function (item) {
 >Array.from(arrLike, function (item) {            return this === undefined ? 2 : 1;        }, undefined) : (2 | 1)[]
->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[]; }
 >arrLike : ArrayLike<number>
->function (item) {            return this === undefined ? 2 : 1;        } : (this: undefined, item: number) => 2 | 1
+>function (item) {            return this === undefined ? 2 : 1;        } : (this: void, item: number) => 2 | 1
 >item : number
 
             return this === undefined ? 2 : 1;
 >this === undefined ? 2 : 1 : 2 | 1
 >this === undefined : boolean
->this : undefined
+>this : void
 >undefined : undefined
 >2 : 2
 >1 : 1
@@ -138,17 +138,17 @@ class A {
 
         Array.from(iterLike, function (item) {
 >Array.from(iterLike, function (item) {            return this === undefined ? 2 : 1;        }, undefined) : (2 | 1)[]
->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[]; }
 >iterLike : Iterable<number>
->function (item) {            return this === undefined ? 2 : 1;        } : (this: undefined, item: number) => 2 | 1
+>function (item) {            return this === undefined ? 2 : 1;        } : (this: void, item: number) => 2 | 1
 >item : number
 
             return this === undefined ? 2 : 1;
 >this === undefined ? 2 : 1 : 2 | 1
 >this === undefined : boolean
->this : undefined
+>this : void
 >undefined : undefined
 >2 : 2
 >1 : 1
@@ -174,9 +174,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : string
->options.find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
+>options.find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
 >options : string[]
->find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
+>find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
 >val : string
 >index : number
@@ -195,9 +195,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
 >options : string[]
->findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
 >val : string
 >index : number
@@ -216,48 +216,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: string[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : string[]
->options.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[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >options : 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 (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => string
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: string, index: number) => any
 >val : string
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -265,20 +265,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (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; }
+>options.some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->some : { (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 (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
+>some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -286,20 +286,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : string[]
->options.filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; }
+>options.filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >options : string[]
->filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
+>filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -307,20 +307,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.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; }
+>options.every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->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 (val, index) {            return val === this.options[index];        } : (this: { options: string[]; }, val: string, index: number) => boolean
+>every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : string[]
->this : { options: string[]; }
->options : string[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -334,9 +334,9 @@ class A {
 
         Array.from(arrLike, function (item) {
 >Array.from(arrLike, function (item) {            return this.options[item].length        }, thisObject) : number[]
->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[]; }
 >arrLike : ArrayLike<number>
 >function (item) {            return this.options[item].length        } : (this: { options: string[]; }, item: number) => number
 >item : number
@@ -361,9 +361,9 @@ class A {
 
         Array.from(iterLike, function (item) {
 >Array.from(iterLike, function (item) {            return this.options[item].length        }, thisObject) : number[]
->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[]; }
 >iterLike : Iterable<number>
 >function (item) {            return this.options[item].length        } : (this: { options: string[]; }, item: number) => number
 >item : number
@@ -399,9 +399,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : string
->options.find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
+>options.find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
 >options : string[]
->find : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
+>find : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): string; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): string; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): string; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
 >val : string
 >index : number
@@ -420,9 +420,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
 >options : string[]
->findIndex : { (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: undefined, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: string, index: number, obj: string[]) => boolean): number; (predicate: (this: void, value: string, index: number, obj: string[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: string, index: number, obj: string[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
 >val : string
 >index : number
@@ -441,48 +441,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.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; }
+>options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : 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 (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: ReadonlyArray<string>; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : string[]
->options.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[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >options : 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 (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => string
+>map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: string, index: number) => any
 >val : string
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -490,20 +490,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (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; }
+>options.some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->some : { (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 (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
+>some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -511,20 +511,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : string[]
->options.filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; }
+>options.filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >options : string[]
->filter : { (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any): string[]; (callbackfn: (this: undefined, value: string, index: number, array: string[]) => any, thisArg: undefined): string[]; <Z>(callbackfn: (this: Z, value: string, index: number, array: string[]) => any, thisArg: Z): string[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
+>filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -532,20 +532,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.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; }
+>options.every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->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 (val, index) {            return val === this.options[index];        } : (this: { options: ReadonlyArray<string>; }, val: string, index: number) => boolean
+>every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : string
->this.options[index] : string
->this.options : ReadonlyArray<string>
->this : { options: ReadonlyArray<string>; }
->options : ReadonlyArray<string>
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -571,9 +571,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Int8Array
->options.find : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
+>options.find : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
 >options : Int8Array[]
->find : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
+>find : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): Int8Array; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): Int8Array; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): Int8Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -592,9 +592,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
 >options : Int8Array[]
->findIndex : { (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: undefined, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean): number; (predicate: (this: void, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int8Array, index: number, obj: Int8Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -613,48 +613,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void): void; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
 >options : Int8Array[]
->forEach : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void): void; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
+>forEach : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int8Array
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Int8Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Int8Array[]
->options.map : { <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U]; <U>(this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
 >options : Int8Array[]
->map : { <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U, U]; <U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Int8Array, Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): [U, U]; <U>(this: [Int8Array, Int8Array], callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Int8Array, Int8Array], callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => Int8Array
+>map : <U>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Int8Array, index: number) => any
 >val : Int8Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Int8Array
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -662,20 +662,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >options : Int8Array[]
->some : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
+>some : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int8Array
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -683,20 +683,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Int8Array[]
->options.filter : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any): Int8Array[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: undefined): Int8Array[]; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: Z): Int8Array[]; }
+>options.filter : { <S extends Int8Array>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
 >options : Int8Array[]
->filter : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any): Int8Array[]; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: undefined): Int8Array[]; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => any, thisArg: Z): Int8Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
+>filter : { <S extends Int8Array>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int8Array
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -704,20 +704,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >options : Int8Array[]
->every : { (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int8Array[]; }, val: Int8Array, index: number) => boolean
+>every : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int8Array
->this.options[index] : Int8Array
->this.options : Int8Array[]
->this : { options: Int8Array[]; }
->options : Int8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -743,9 +743,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8Array
->options.find : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
+>options.find : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
 >options : Uint8Array[]
->find : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
+>find : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): Uint8Array; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): Uint8Array; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): Uint8Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -764,9 +764,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
 >options : Uint8Array[]
->findIndex : { (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: undefined, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean): number; (predicate: (this: void, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8Array, index: number, obj: Uint8Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -785,48 +785,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void): void; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
 >options : Uint8Array[]
->forEach : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void): void; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
+>forEach : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8Array
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Uint8Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Uint8Array[]
->options.map : { <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U]; <U>(this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
 >options : Uint8Array[]
->map : { <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U, U]; <U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint8Array, Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): [U, U]; <U>(this: [Uint8Array, Uint8Array], callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint8Array, Uint8Array], callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => Uint8Array
+>map : <U>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint8Array, index: number) => any
 >val : Uint8Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Uint8Array
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -834,20 +834,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint8Array[]
->some : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
+>some : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8Array
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -855,20 +855,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8Array[]
->options.filter : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any): Uint8Array[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: undefined): Uint8Array[]; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: Z): Uint8Array[]; }
+>options.filter : { <S extends Uint8Array>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
 >options : Uint8Array[]
->filter : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any): Uint8Array[]; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: undefined): Uint8Array[]; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg: Z): Uint8Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
+>filter : { <S extends Uint8Array>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8Array
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -876,20 +876,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint8Array[]
->every : { (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8Array[]; }, val: Uint8Array, index: number) => boolean
+>every : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8Array
->this.options[index] : Uint8Array
->this.options : Uint8Array[]
->this : { options: Uint8Array[]; }
->options : Uint8Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -915,9 +915,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Float32Array
->options.find : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
+>options.find : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
 >options : Float32Array[]
->find : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
+>find : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): Float32Array; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): Float32Array; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): Float32Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -936,9 +936,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
 >options : Float32Array[]
->findIndex : { (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: undefined, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean): number; (predicate: (this: void, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float32Array, index: number, obj: Float32Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -957,48 +957,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void): void; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
 >options : Float32Array[]
->forEach : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void): void; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
+>forEach : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float32Array
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Float32Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Float32Array[]
->options.map : { <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U]; <U>(this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
 >options : Float32Array[]
->map : { <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U, U]; <U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Float32Array, Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): [U, U]; <U>(this: [Float32Array, Float32Array], callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Float32Array, Float32Array], callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => Float32Array
+>map : <U>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Float32Array, index: number) => any
 >val : Float32Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Float32Array
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1006,20 +1006,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >options : Float32Array[]
->some : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
+>some : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float32Array
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1027,20 +1027,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Float32Array[]
->options.filter : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any): Float32Array[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: undefined): Float32Array[]; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: Z): Float32Array[]; }
+>options.filter : { <S extends Float32Array>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
 >options : Float32Array[]
->filter : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any): Float32Array[]; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: undefined): Float32Array[]; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => any, thisArg: Z): Float32Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
+>filter : { <S extends Float32Array>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float32Array
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1048,20 +1048,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >options : Float32Array[]
->every : { (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float32Array[]; }, val: Float32Array, index: number) => boolean
+>every : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float32Array
->this.options[index] : Float32Array
->this.options : Float32Array[]
->this : { options: Float32Array[]; }
->options : Float32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1087,9 +1087,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8ClampedArray
->options.find : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
+>options.find : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
 >options : Uint8ClampedArray[]
->find : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
+>find : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): Uint8ClampedArray; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): Uint8ClampedArray; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): Uint8ClampedArray; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1108,9 +1108,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
 >options : Uint8ClampedArray[]
->findIndex : { (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: undefined, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean): number; (predicate: (this: void, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint8ClampedArray, index: number, obj: Uint8ClampedArray[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1129,48 +1129,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void): void; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
 >options : Uint8ClampedArray[]
->forEach : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void): void; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
+>forEach : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8ClampedArray
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Uint8ClampedArray[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Uint8ClampedArray[]
->options.map : { <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
 >options : Uint8ClampedArray[]
->map : { <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): [U, U]; <U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint8ClampedArray, Uint8ClampedArray], callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => Uint8ClampedArray
+>map : <U>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint8ClampedArray, index: number) => any
 >val : Uint8ClampedArray
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Uint8ClampedArray
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1178,20 +1178,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >options : Uint8ClampedArray[]
->some : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
+>some : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8ClampedArray
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1199,20 +1199,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8ClampedArray[]
->options.filter : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any): Uint8ClampedArray[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: undefined): Uint8ClampedArray[]; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: Z): Uint8ClampedArray[]; }
+>options.filter : { <S extends Uint8ClampedArray>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
 >options : Uint8ClampedArray[]
->filter : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any): Uint8ClampedArray[]; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: undefined): Uint8ClampedArray[]; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg: Z): Uint8ClampedArray[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
+>filter : { <S extends Uint8ClampedArray>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8ClampedArray
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1220,20 +1220,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >options : Uint8ClampedArray[]
->every : { (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint8ClampedArray[]; }, val: Uint8ClampedArray, index: number) => boolean
+>every : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint8ClampedArray
->this.options[index] : Uint8ClampedArray
->this.options : Uint8ClampedArray[]
->this : { options: Uint8ClampedArray[]; }
->options : Uint8ClampedArray[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1259,9 +1259,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Int16Array
->options.find : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
+>options.find : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
 >options : Int16Array[]
->find : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
+>find : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): Int16Array; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): Int16Array; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): Int16Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1280,9 +1280,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
 >options : Int16Array[]
->findIndex : { (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: undefined, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean): number; (predicate: (this: void, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Int16Array, index: number, obj: Int16Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1301,48 +1301,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void): void; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
 >options : Int16Array[]
->forEach : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void): void; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
+>forEach : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int16Array
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Int16Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Int16Array[]
->options.map : { <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U]; <U>(this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
 >options : Int16Array[]
->map : { <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U, U]; <U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Int16Array, Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): [U, U]; <U>(this: [Int16Array, Int16Array], callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Int16Array, Int16Array], callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => Int16Array
+>map : <U>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Int16Array, index: number) => any
 >val : Int16Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Int16Array
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1350,20 +1350,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >options : Int16Array[]
->some : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
+>some : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int16Array
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1371,20 +1371,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Int16Array[]
->options.filter : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any): Int16Array[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: undefined): Int16Array[]; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: Z): Int16Array[]; }
+>options.filter : { <S extends Int16Array>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
 >options : Int16Array[]
->filter : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any): Int16Array[]; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: undefined): Int16Array[]; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => any, thisArg: Z): Int16Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
+>filter : { <S extends Int16Array>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int16Array
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1392,20 +1392,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >options : Int16Array[]
->every : { (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Int16Array[]; }, val: Int16Array, index: number) => boolean
+>every : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Int16Array
->this.options[index] : Int16Array
->this.options : Int16Array[]
->this : { options: Int16Array[]; }
->options : Int16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1431,9 +1431,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint16Array
->options.find : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
+>options.find : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
 >options : Uint16Array[]
->find : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
+>find : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): Uint16Array; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): Uint16Array; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): Uint16Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1452,9 +1452,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
 >options : Uint16Array[]
->findIndex : { (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: undefined, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean): number; (predicate: (this: void, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint16Array, index: number, obj: Uint16Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1473,48 +1473,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void): void; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
 >options : Uint16Array[]
->forEach : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void): void; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
+>forEach : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint16Array
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Uint16Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Uint16Array[]
->options.map : { <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U]; <U>(this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
 >options : Uint16Array[]
->map : { <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U, U]; <U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint16Array, Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): [U, U]; <U>(this: [Uint16Array, Uint16Array], callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint16Array, Uint16Array], callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => Uint16Array
+>map : <U>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint16Array, index: number) => any
 >val : Uint16Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Uint16Array
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1522,20 +1522,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint16Array[]
->some : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
+>some : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint16Array
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1543,20 +1543,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint16Array[]
->options.filter : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any): Uint16Array[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: undefined): Uint16Array[]; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: Z): Uint16Array[]; }
+>options.filter : { <S extends Uint16Array>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
 >options : Uint16Array[]
->filter : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any): Uint16Array[]; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: undefined): Uint16Array[]; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg: Z): Uint16Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
+>filter : { <S extends Uint16Array>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint16Array
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1564,20 +1564,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint16Array[]
->every : { (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint16Array[]; }, val: Uint16Array, index: number) => boolean
+>every : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint16Array
->this.options[index] : Uint16Array
->this.options : Uint16Array[]
->this : { options: Uint16Array[]; }
->options : Uint16Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1603,9 +1603,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint32Array
->options.find : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
+>options.find : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
 >options : Uint32Array[]
->find : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
+>find : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): Uint32Array; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): Uint32Array; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): Uint32Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1624,9 +1624,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
 >options : Uint32Array[]
->findIndex : { (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: undefined, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean): number; (predicate: (this: void, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Uint32Array, index: number, obj: Uint32Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1645,48 +1645,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void): void; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
 >options : Uint32Array[]
->forEach : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void): void; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
+>forEach : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint32Array
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Uint32Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Uint32Array[]
->options.map : { <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U]; <U>(this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
 >options : Uint32Array[]
->map : { <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U, U]; <U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Uint32Array, Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): [U, U]; <U>(this: [Uint32Array, Uint32Array], callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Uint32Array, Uint32Array], callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => Uint32Array
+>map : <U>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint32Array, index: number) => any
 >val : Uint32Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Uint32Array
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1694,20 +1694,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint32Array[]
->some : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
+>some : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint32Array
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1715,20 +1715,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint32Array[]
->options.filter : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any): Uint32Array[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: undefined): Uint32Array[]; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: Z): Uint32Array[]; }
+>options.filter : { <S extends Uint32Array>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
 >options : Uint32Array[]
->filter : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any): Uint32Array[]; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: undefined): Uint32Array[]; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg: Z): Uint32Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
+>filter : { <S extends Uint32Array>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint32Array
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1736,20 +1736,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint32Array[]
->every : { (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Uint32Array[]; }, val: Uint32Array, index: number) => boolean
+>every : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Uint32Array
->this.options[index] : Uint32Array
->this.options : Uint32Array[]
->this : { options: Uint32Array[]; }
->options : Uint32Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1775,9 +1775,9 @@ class A {
 
         options.find(function (val, index) {
 >options.find(function (val, index) {            return val === this.options[index];        }, thisObject) : Float64Array
->options.find : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
+>options.find : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
 >options : Float64Array[]
->find : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
+>find : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): Float64Array; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): Float64Array; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): Float64Array; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -1796,9 +1796,9 @@ class A {
 
         options.findIndex(function (val, index) {
 >options.findIndex(function (val, index) {            return val === this.options[index];        }, thisObject) : number
->options.findIndex : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
+>options.findIndex : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
 >options : Float64Array[]
->findIndex : { (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: undefined, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
+>findIndex : { (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean): number; (predicate: (this: void, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: undefined): number; <Z>(predicate: (this: Z, value: Float64Array, index: number, obj: Float64Array[]) => boolean, thisArg: Z): number; }
 >function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -1817,48 +1817,48 @@ class A {
 
         options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void): void; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: Z): void; }
+>options.forEach : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
 >options : Float64Array[]
->forEach : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void): void; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: undefined): void; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => void, thisArg: Z): void; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
+>forEach : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
+>function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float64Array
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
 >thisObject : { options: Float64Array[]; }
 
         options.map(function (val, index) {
->options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : Float64Array[]
->options.map : { <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U]; <U>(this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): U[]; }
+>options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
+>options.map : <U>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
 >options : Float64Array[]
->map : { <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U, U]; <U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U, U]; <Z, U>(this: [Float64Array, Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U, U]; <U>(this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): [U, U]; <U>(this: [Float64Array, Float64Array], callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): [U, U]; <Z, U>(this: [Float64Array, Float64Array], callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): [U, U]; <U>(callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U): U[]; <U>(callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: undefined): U[]; <Z, U>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => U, thisArg: Z): U[]; }
->function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => Float64Array
+>map : <U>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
+>function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Float64Array, index: number) => any
 >val : Float64Array
 >index : number
 
             if (val === this.options[index])
 >val === this.options[index] : boolean
 >val : Float64Array
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
                 return this.options[index];
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1866,20 +1866,20 @@ class A {
 
         options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; }
+>options.some : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >options : Float64Array[]
->some : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
+>some : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float64Array
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1887,20 +1887,20 @@ class A {
 
         options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Float64Array[]
->options.filter : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any): Float64Array[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: undefined): Float64Array[]; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: Z): Float64Array[]; }
+>options.filter : { <S extends Float64Array>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
 >options : Float64Array[]
->filter : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any): Float64Array[]; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: undefined): Float64Array[]; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => any, thisArg: Z): Float64Array[]; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
+>filter : { <S extends Float64Array>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
+>function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float64Array
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
@@ -1908,20 +1908,20 @@ class A {
 
         options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; }
+>options.every : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >options : Float64Array[]
->every : { (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean): boolean; (callbackfn: (this: undefined, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: undefined): boolean; <Z>(callbackfn: (this: Z, value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg: Z): boolean; }
->function (val, index) {            return val === this.options[index];        } : (this: { options: Float64Array[]; }, val: Float64Array, index: number) => boolean
+>every : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
 
             return val === this.options[index];
 >val === this.options[index] : boolean
 >val : Float64Array
->this.options[index] : Float64Array
->this.options : Float64Array[]
->this : { options: Float64Array[]; }
->options : Float64Array[]
+>this.options[index] : any
+>this.options : any
+>this : any
+>options : any
 >index : number
 
         }, thisObject);
diff --git a/tests/baselines/reference/transpile/Report an error when compiler-options module-kind is out-of-range.errors.txt b/tests/baselines/reference/transpile/Report an error when compiler-options module-kind is out-of-range.errors.txt
index d746f35cbe7..f746915da7d 100644
--- a/tests/baselines/reference/transpile/Report an error when compiler-options module-kind is out-of-range.errors.txt	
+++ b/tests/baselines/reference/transpile/Report an error when compiler-options module-kind is out-of-range.errors.txt	
@@ -1,6 +1,6 @@
-error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.
+error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.
 
 
-!!! error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.
+!!! error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.
 ==== file.ts (0 errors) ====
     
\ No newline at end of file
diff --git a/tests/baselines/reference/transpile/Report an error when compiler-options target-script is out-of-range.errors.txt b/tests/baselines/reference/transpile/Report an error when compiler-options target-script is out-of-range.errors.txt
index d746f35cbe7..f746915da7d 100644
--- a/tests/baselines/reference/transpile/Report an error when compiler-options target-script is out-of-range.errors.txt	
+++ b/tests/baselines/reference/transpile/Report an error when compiler-options target-script is out-of-range.errors.txt	
@@ -1,6 +1,6 @@
-error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.
+error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.
 
 
-!!! error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015'.
+!!! error TS6046: Argument for '--module' option must be: 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'esnext'.
 ==== file.ts (0 errors) ====
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json
index 97f59dea8ea..772c218eb4e 100644
--- a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json
index b90e3fc6c58..7a9b895636c 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true,                           /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     "noUnusedLocals": true                    /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json
index 482cfa6a9d5..70d5ed9d738 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json
index c6a26629dab..914b9d99d1b 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   },
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json
index 72289dd1787..50bd28442bb 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     "lib": ["es5","es2015.promise"],          /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json
index 97f59dea8ea..772c218eb4e 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json
index 1ac7c8c54da..afae7193d58 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     "lib": ["es5","es2015.core"],             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json
index 33a9ecc5cd4..a87fe9c5206 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json	
@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    /* Basic Options */                       
+    /* Basic Options */
     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'. */
+    "module": "commonjs",                     /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation:  */
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
@@ -17,21 +17,21 @@
     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-                                              
-    /* Strict Type-Checking Options */        
+
+    /* Strict Type-Checking Options */
     "strict": true,                           /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-                                              
-    /* Additional Checks */                   
+
+    /* Additional Checks */
     // "noUnusedLocals": true,                /* Report errors on unused locals. */
     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-                                              
-    /* Module Resolution Options */           
+
+    /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
@@ -39,14 +39,14 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     "types": ["jquery","mocha"]               /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-                                              
-    /* Source Map Options */                  
+
+    /* Source Map Options */
     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-                                              
-    /* Experimental Options */                
+
+    /* Experimental Options */
     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
   }
diff --git a/tests/baselines/reference/tsxAttributeResolution1.errors.txt b/tests/baselines/reference/tsxAttributeResolution1.errors.txt
index f6c84f80fa5..a6fe4154dfe 100644
--- a/tests/baselines/reference/tsxAttributeResolution1.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution1.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/conformance/jsx/file.tsx(23,8): error TS2322: Type '{ x: "0"; }' is not assignable to type 'Attribs1'.
   Types of property 'x' are incompatible.
     Type '"0"' is not assignable to type 'number'.
-tests/cases/conformance/jsx/file.tsx(24,8): error TS2339: Property 'y' does not exist on type 'Attribs1'.
-tests/cases/conformance/jsx/file.tsx(25,8): error TS2339: Property 'y' does not exist on type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(24,8): error TS2559: Type '{ y: 0; }' has no properties in common with type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(25,8): error TS2559: Type '{ y: "foo"; }' has no properties in common with type 'Attribs1'.
 tests/cases/conformance/jsx/file.tsx(26,8): error TS2322: Type '{ x: "32"; }' is not assignable to type 'Attribs1'.
   Types of property 'x' are incompatible.
     Type '"32"' is not assignable to type 'number'.
-tests/cases/conformance/jsx/file.tsx(27,8): error TS2339: Property 'var' does not exist on type 'Attribs1'.
+tests/cases/conformance/jsx/file.tsx(27,8): error TS2559: Type '{ var: "10"; }' has no properties in common with type 'Attribs1'.
 tests/cases/conformance/jsx/file.tsx(29,1): error TS2322: Type '{}' is not assignable to type '{ reqd: string; }'.
   Property 'reqd' is missing in type '{}'.
 tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type '{ reqd: 10; }' is not assignable to type '{ reqd: string; }'.
@@ -44,10 +44,10 @@ tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type '{ reqd: 10; }' i
 !!! error TS2322:     Type '"0"' is not assignable to type 'number'.
     <test1 y={0} />; // Error, no property "y"
            ~~~~~
-!!! error TS2339: Property 'y' does not exist on type 'Attribs1'.
+!!! error TS2559: Type '{ y: 0; }' has no properties in common with type 'Attribs1'.
     <test1 y="foo" />; // Error, no property "y"
            ~~~~~~~
-!!! error TS2339: Property 'y' does not exist on type 'Attribs1'.
+!!! error TS2559: Type '{ y: "foo"; }' has no properties in common with type 'Attribs1'.
     <test1 x="32" />; // Error, "32" is not number
            ~~~~~~
 !!! error TS2322: Type '{ x: "32"; }' is not assignable to type 'Attribs1'.
@@ -55,7 +55,7 @@ tests/cases/conformance/jsx/file.tsx(30,8): error TS2322: Type '{ reqd: 10; }' i
 !!! error TS2322:     Type '"32"' is not assignable to type 'number'.
     <test1 var="10" />; // Error, no 'var' property
            ~~~~~~~~
-!!! error TS2339: Property 'var' does not exist on type 'Attribs1'.
+!!! error TS2559: Type '{ var: "10"; }' has no properties in common with type 'Attribs1'.
     
     <test2 />; // Error, missing reqd
     ~~~~~~~~~
diff --git a/tests/baselines/reference/tsxAttributeResolution11.errors.txt b/tests/baselines/reference/tsxAttributeResolution11.errors.txt
index 907b9bce776..a8a62ae656a 100644
--- a/tests/baselines/reference/tsxAttributeResolution11.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution11.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(11,22): error TS2339: Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
+tests/cases/conformance/jsx/file.tsx(11,22): error TS2559: Type '{ bar: "world"; }' has no properties in common with type 'IntrinsicAttributes & { ref?: string; }'.
 
 
 ==== tests/cases/conformance/jsx/react.d.ts (0 errors) ====
@@ -27,6 +27,6 @@ tests/cases/conformance/jsx/file.tsx(11,22): error TS2339: Property 'bar' does n
     // Should be an OK
     var x = <MyComponent bar='world' />;
                          ~~~~~~~~~~~
-!!! error TS2339: Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
+!!! error TS2559: Type '{ bar: "world"; }' has no properties in common with type 'IntrinsicAttributes & { ref?: string; }'.
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxAttributeResolution15.errors.txt b/tests/baselines/reference/tsxAttributeResolution15.errors.txt
index 2ab79ea7aae..07b54411aab 100644
--- a/tests/baselines/reference/tsxAttributeResolution15.errors.txt
+++ b/tests/baselines/reference/tsxAttributeResolution15.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(11,21): error TS2339: Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(11,21): error TS2559: Type '{ prop1: "hello"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (1 errors) ====
@@ -14,7 +14,7 @@ tests/cases/conformance/jsx/file.tsx(11,21): error TS2339: Property 'prop1' does
     // Error
     let a = <BigGreeter prop1="hello" />
                         ~~~~~~~~~~~~~
-!!! error TS2339: Property 'prop1' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
+!!! error TS2559: Type '{ prop1: "hello"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<BigGreeter> & { children?: ReactNode; }'.
     
     // OK
     let b = <BigGreeter ref={(input) => { this.textInput = input; }} />
diff --git a/tests/baselines/reference/tsxAttributeResolution16.symbols b/tests/baselines/reference/tsxAttributeResolution16.symbols
index d2ae05714ef..551e45b3542 100644
--- a/tests/baselines/reference/tsxAttributeResolution16.symbols
+++ b/tests/baselines/reference/tsxAttributeResolution16.symbols
@@ -35,9 +35,9 @@ type Properties = CanadianAddress | AmericanAddress;
 
 export class AddressComp extends React.Component<Properties, void> {
 >AddressComp : Symbol(AddressComp, Decl(file.tsx, 15, 52))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >Properties : Symbol(Properties, Decl(file.tsx, 13, 1))
 
   public render() {
diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols
index ff8926b0ab0..470d33862d5 100644
--- a/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols
+++ b/tests/baselines/reference/tsxDefaultAttributesResolution1.symbols
@@ -10,17 +10,17 @@ interface Prop {
 }
 class Poisoned extends React.Component<Prop, {}> {
 >Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols
index 61d007ddbef..bb72837041c 100644
--- a/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols
+++ b/tests/baselines/reference/tsxDefaultAttributesResolution2.symbols
@@ -10,17 +10,17 @@ interface Prop {
 }
 class Poisoned extends React.Component<Prop, {}> {
 >Poisoned : Symbol(Poisoned, Decl(file.tsx, 4, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(Poisoned.render, Decl(file.tsx, 5, 50))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxElementResolution11.errors.txt b/tests/baselines/reference/tsxElementResolution11.errors.txt
index 878f5a8b337..24ff907f0e0 100644
--- a/tests/baselines/reference/tsxElementResolution11.errors.txt
+++ b/tests/baselines/reference/tsxElementResolution11.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(17,7): error TS2339: Property 'x' does not exist on type '{ q?: number; }'.
+tests/cases/conformance/jsx/file.tsx(17,7): error TS2559: Type '{ x: 10; }' has no properties in common with type '{ q?: number; }'.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (1 errors) ====
@@ -20,7 +20,7 @@ tests/cases/conformance/jsx/file.tsx(17,7): error TS2339: Property 'x' does not
     var Obj2: Obj2type;
     <Obj2 x={10} />; // Error
           ~~~~~~
-!!! error TS2339: Property 'x' does not exist on type '{ q?: number; }'.
+!!! error TS2559: Type '{ x: 10; }' has no properties in common with type '{ q?: number; }'.
     
     interface Obj3type {
     	new(n: string): { x: number; };
diff --git a/tests/baselines/reference/tsxGenericAttributesType1.symbols b/tests/baselines/reference/tsxGenericAttributesType1.symbols
index 473de9b5c72..054661e609b 100644
--- a/tests/baselines/reference/tsxGenericAttributesType1.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType1.symbols
@@ -7,10 +7,10 @@ const decorator = function <T>(Component: React.StatelessComponent<T>): React.St
 >T : Symbol(T, Decl(file.tsx, 2, 28))
 >Component : Symbol(Component, Decl(file.tsx, 2, 31))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 2, 28))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 2, 28))
 
     return (props) => <Component {...props}></Component>
@@ -27,10 +27,10 @@ const decorator2 = function <T extends { x: number }>(Component: React.Stateless
 >x : Symbol(x, Decl(file.tsx, 6, 40))
 >Component : Symbol(Component, Decl(file.tsx, 6, 54))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 6, 29))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 6, 29))
 
     return (props) => <Component {...props} x={2} ></Component>
@@ -50,10 +50,10 @@ const decorator3 = function <T extends { x: number }, U extends { x: number } >(
 >x : Symbol(x, Decl(file.tsx, 10, 65))
 >Component : Symbol(Component, Decl(file.tsx, 10, 80))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 10, 29))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >T : Symbol(T, Decl(file.tsx, 10, 29))
 
     return (props) => <Component x={2} {...props} ></Component>
diff --git a/tests/baselines/reference/tsxGenericAttributesType3.symbols b/tests/baselines/reference/tsxGenericAttributesType3.symbols
index 8c235257e8d..c19d8150130 100644
--- a/tests/baselines/reference/tsxGenericAttributesType3.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType3.symbols
@@ -7,25 +7,25 @@ class B1<T extends { x: string } = { x:string } > extends React.Component<T, {}>
 >T : Symbol(T, Decl(file.tsx, 2, 9))
 >x : Symbol(x, Decl(file.tsx, 2, 20))
 >x : Symbol(x, Decl(file.tsx, 2, 36))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >T : Symbol(T, Decl(file.tsx, 2, 9))
 
     render() {
 >render : Symbol(B1.render, Decl(file.tsx, 2, 82))
 
         return <div>hi</div>; 
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 class B<U> extends React.Component<U, {}> {
 >B : Symbol(B, Decl(file.tsx, 6, 1))
 >U : Symbol(U, Decl(file.tsx, 7, 8))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >U : Symbol(U, Decl(file.tsx, 7, 8))
 
     render() {
@@ -33,9 +33,9 @@ class B<U> extends React.Component<U, {}> {
 
         return <B1 {...this.props} x="hi" />;
 >B1 : Symbol(B1, Decl(file.tsx, 0, 32))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol(B, Decl(file.tsx, 6, 1))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >x : Symbol(x, Decl(file.tsx, 9, 34))
     }
 }
diff --git a/tests/baselines/reference/tsxGenericAttributesType6.symbols b/tests/baselines/reference/tsxGenericAttributesType6.symbols
index 27c8ed2d6dc..af4f0c947c2 100644
--- a/tests/baselines/reference/tsxGenericAttributesType6.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType6.symbols
@@ -7,25 +7,25 @@ class B1<T extends { x: string } = { x:string } > extends React.Component<T, {}>
 >T : Symbol(T, Decl(file.tsx, 2, 9))
 >x : Symbol(x, Decl(file.tsx, 2, 20))
 >x : Symbol(x, Decl(file.tsx, 2, 36))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >T : Symbol(T, Decl(file.tsx, 2, 9))
 
     render() {
 >render : Symbol(B1.render, Decl(file.tsx, 2, 82))
 
         return <div>hi</div>; 
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 class B<U> extends React.Component<U, {}> {
 >B : Symbol(B, Decl(file.tsx, 6, 1))
 >U : Symbol(U, Decl(file.tsx, 7, 8))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >U : Symbol(U, Decl(file.tsx, 7, 8))
 
     props: U;
diff --git a/tests/baselines/reference/tsxGenericAttributesType7.symbols b/tests/baselines/reference/tsxGenericAttributesType7.symbols
index e31042bd843..92c07c74e2e 100644
--- a/tests/baselines/reference/tsxGenericAttributesType7.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType7.symbols
@@ -7,8 +7,8 @@ declare function Component<T>(props: T) : JSX.Element;
 >T : Symbol(T, Decl(file.tsx, 2, 27))
 >props : Symbol(props, Decl(file.tsx, 2, 30))
 >T : Symbol(T, Decl(file.tsx, 2, 27))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 const decorator = function <U>(props: U) {
 >decorator : Symbol(decorator, Decl(file.tsx, 3, 5))
diff --git a/tests/baselines/reference/tsxGenericAttributesType8.symbols b/tests/baselines/reference/tsxGenericAttributesType8.symbols
index 516dbe9c322..65ccdcad4df 100644
--- a/tests/baselines/reference/tsxGenericAttributesType8.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType8.symbols
@@ -7,8 +7,8 @@ declare function Component<T>(props: T) : JSX.Element;
 >T : Symbol(T, Decl(file.tsx, 2, 27))
 >props : Symbol(props, Decl(file.tsx, 2, 30))
 >T : Symbol(T, Decl(file.tsx, 2, 27))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 const decorator = function <U>(props: U) {
 >decorator : Symbol(decorator, Decl(file.tsx, 3, 5))
diff --git a/tests/baselines/reference/tsxGenericAttributesType9.js b/tests/baselines/reference/tsxGenericAttributesType9.js
index b7b90736ad1..c53a8de520e 100644
--- a/tests/baselines/reference/tsxGenericAttributesType9.js
+++ b/tests/baselines/reference/tsxGenericAttributesType9.js
@@ -1,7 +1,7 @@
 //// [file.tsx]
 import React = require('react');
 
-export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P> {
+export function makeP<P>(Ctor: React.ComponentClass<P>) {
 	return class extends React.PureComponent<P, void> {
 		public render(): JSX.Element {
 			return (
@@ -9,7 +9,9 @@ export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P>
 			);
 		}
 	};
-}
+}
+
+
 
 //// [file.jsx]
 "use strict";
diff --git a/tests/baselines/reference/tsxGenericAttributesType9.symbols b/tests/baselines/reference/tsxGenericAttributesType9.symbols
index f4df2e79408..2771e0a07eb 100644
--- a/tests/baselines/reference/tsxGenericAttributesType9.symbols
+++ b/tests/baselines/reference/tsxGenericAttributesType9.symbols
@@ -2,36 +2,35 @@
 import React = require('react');
 >React : Symbol(React, Decl(file.tsx, 0, 0))
 
-export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P> {
+export function makeP<P>(Ctor: React.ComponentClass<P>) {
 >makeP : Symbol(makeP, Decl(file.tsx, 0, 32))
 >P : Symbol(P, Decl(file.tsx, 2, 22))
 >Ctor : Symbol(Ctor, Decl(file.tsx, 2, 25))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->ComponentClass : Symbol(React.ComponentClass, Decl(react.d.ts, 204, 5))
->P : Symbol(P, Decl(file.tsx, 2, 22))
->React : Symbol(React, Decl(file.tsx, 0, 0))
->ComponentClass : Symbol(React.ComponentClass, Decl(react.d.ts, 204, 5))
+>ComponentClass : Symbol(React.ComponentClass, Decl(react.d.ts, 205, 5))
 >P : Symbol(P, Decl(file.tsx, 2, 22))
 
 	return class extends React.PureComponent<P, void> {
->React.PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 179, 5))
+>React.PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 180, 5))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 179, 5))
+>PureComponent : Symbol(React.PureComponent, Decl(react.d.ts, 180, 5))
 >P : Symbol(P, Decl(file.tsx, 2, 22))
 
 		public render(): JSX.Element {
 >render : Symbol((Anonymous class).render, Decl(file.tsx, 3, 52))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 			return (
 				<Ctor {...this.props } />
 >Ctor : Symbol(Ctor, Decl(file.tsx, 2, 25))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol((Anonymous class), Decl(file.tsx, 3, 7))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 
 			);
 		}
 	};
 }
+
+
diff --git a/tests/baselines/reference/tsxGenericAttributesType9.types b/tests/baselines/reference/tsxGenericAttributesType9.types
index a1d7efc49be..2cc8a57bc5d 100644
--- a/tests/baselines/reference/tsxGenericAttributesType9.types
+++ b/tests/baselines/reference/tsxGenericAttributesType9.types
@@ -2,15 +2,12 @@
 import React = require('react');
 >React : typeof React
 
-export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P> {
->makeP : <P>(Ctor: React.ComponentClass<P>) => React.ComponentClass<P>
+export function makeP<P>(Ctor: React.ComponentClass<P>) {
+>makeP : <P>(Ctor: React.ComponentClass<P>) => typeof (Anonymous class)
 >P : P
 >Ctor : React.ComponentClass<P>
 >React : any
 >ComponentClass : React.ComponentClass<P>
->P : P
->React : any
->ComponentClass : React.ComponentClass<P>
 >P : P
 
 	return class extends React.PureComponent<P, void> {
@@ -39,3 +36,5 @@ export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P>
 		}
 	};
 }
+
+
diff --git a/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter1.symbols b/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter1.symbols
index b4aaafb21ab..fbdff5c5f39 100644
--- a/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter1.symbols
+++ b/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter1.symbols
@@ -16,9 +16,9 @@ declare class MyComp<P = Prop> extends React.Component<P, {}> {
 >MyComp : Symbol(MyComp, Decl(file.tsx, 5, 1))
 >P : Symbol(P, Decl(file.tsx, 7, 21))
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >P : Symbol(P, Decl(file.tsx, 7, 21))
 
     internalProp: P;
diff --git a/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.errors.txt b/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.errors.txt
index 230ca1e2795..54f36da535b 100644
--- a/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.errors.txt
+++ b/tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/conformance/jsx/file.tsx(16,17): error TS2339: Property 'a' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
-tests/cases/conformance/jsx/file.tsx(17,18): error TS2339: Property 'a' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(16,17): error TS2559: Type '{ a: 10; b: "hi"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(17,18): error TS2559: Type '{ a: "hi"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (2 errors) ====
@@ -19,8 +19,8 @@ tests/cases/conformance/jsx/file.tsx(17,18): error TS2339: Property 'a' does not
     
     // Error
     let x = <MyComp a={10} b="hi" />
-                    ~~~~~~
-!!! error TS2339: Property 'a' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
+                    ~~~~~~~~~~~~~
+!!! error TS2559: Type '{ a: 10; b: "hi"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
     let x2 = <MyComp a="hi"/>
                      ~~~~~~
-!!! error TS2339: Property 'a' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
\ No newline at end of file
+!!! error TS2559: Type '{ a: "hi"; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<MyComp<{}>> & { children?: ReactNode; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution1.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution1.symbols
index 273ea39281a..82a4e5cc822 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution1.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution1.symbols
@@ -4,16 +4,16 @@ import React = require('react');
 
 class Poisoned extends React.Component<{}, {}> {
 >Poisoned : Symbol(Poisoned, Decl(file.tsx, 0, 32))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(Poisoned.render, Decl(file.tsx, 2, 48))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution11.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution11.symbols
index 5646934ef41..ebea95a29e6 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution11.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution11.symbols
@@ -39,17 +39,17 @@ interface Prop {
 
 class OverWriteAttr extends React.Component<Prop, {}> {
 >OverWriteAttr : Symbol(OverWriteAttr, Decl(file.tsx, 15, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >Prop : Symbol(Prop, Decl(file.tsx, 9, 1))
 
     render() {
 >render : Symbol(OverWriteAttr.render, Decl(file.tsx, 17, 55))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution13.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution13.symbols
index 2e146225792..6b8d637f82c 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution13.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution13.symbols
@@ -52,9 +52,9 @@ function ChildComponent({ property1 }: AnotherComponentProps) {
 
     return (
         <span>{property1}</span>
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 >property1 : Symbol(property1, Decl(file.tsx, 23, 25))
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 
     );
 }
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution15.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution15.symbols
index 00e10954821..013e2553b0d 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution15.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution15.symbols
@@ -47,9 +47,9 @@ function AnotherComponent({ property1 }: AnotherComponentProps) {
 
     return (
         <span>{property1}</span>
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 >property1 : Symbol(property1, Decl(file.tsx, 19, 27))
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
 
     );
 }
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution3.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution3.symbols
index 05de039a49a..125244c229b 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution3.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution3.symbols
@@ -14,17 +14,17 @@ interface PoisonedProp {
 
 class Poisoned extends React.Component<PoisonedProp, {}> {
 >Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >PoisonedProp : Symbol(PoisonedProp, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(Poisoned.render, Decl(file.tsx, 7, 58))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution4.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution4.symbols
index 93d8535658e..ccf2e68d4f1 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution4.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution4.symbols
@@ -14,17 +14,17 @@ interface PoisonedProp {
 
 class Poisoned extends React.Component<PoisonedProp, {}> {
 >Poisoned : Symbol(Poisoned, Decl(file.tsx, 5, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >PoisonedProp : Symbol(PoisonedProp, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(Poisoned.render, Decl(file.tsx, 7, 58))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
@@ -48,16 +48,16 @@ let p = <Poisoned {...obj} />;
 
 class EmptyProp extends React.Component<{}, {}> {
 >EmptyProp : Symbol(EmptyProp, Decl(file.tsx, 19, 30))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(EmptyProp.render, Decl(file.tsx, 21, 49))
 
         return <div>Default hi</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution5.errors.txt b/tests/baselines/reference/tsxSpreadAttributesResolution5.errors.txt
index be7018512f9..5642f06897c 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution5.errors.txt
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution5.errors.txt
@@ -2,9 +2,10 @@ tests/cases/conformance/jsx/file.tsx(20,19): error TS2322: Type '{ x: string; y:
   Type '{ x: string; y: number; }' is not assignable to type 'PoisonedProp'.
     Types of property 'y' are incompatible.
       Type 'number' is not assignable to type '2'.
+tests/cases/conformance/jsx/file.tsx(33,20): error TS2559: Type '{ prop1: boolean; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<EmptyProp> & { children?: ReactNode; }'.
 
 
-==== tests/cases/conformance/jsx/file.tsx (1 errors) ====
+==== tests/cases/conformance/jsx/file.tsx (2 errors) ====
     import React = require('react');
     
     interface PoisonedProp {
@@ -42,4 +43,6 @@ tests/cases/conformance/jsx/file.tsx(20,19): error TS2322: Type '{ x: string; y:
         prop1: false
     }
     // Ok
-    let e = <EmptyProp {...o} />;
\ No newline at end of file
+    let e = <EmptyProp {...o} />;
+                       ~~~~~~
+!!! error TS2559: Type '{ prop1: boolean; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<EmptyProp> & { children?: ReactNode; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution7.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution7.symbols
index 8a6e3fd317b..66be8dc9188 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution7.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution7.symbols
@@ -13,17 +13,17 @@ type TextProps = { editable: false }
 
 class TextComponent extends React.Component<TextProps, {}> {
 >TextComponent : Symbol(TextComponent, Decl(file.tsx, 3, 71))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >TextProps : Symbol(TextProps, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(TextComponent.render, Decl(file.tsx, 5, 60))
 
         return <span>Some Text..</span>;
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
->span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2460, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
+>span : Symbol(JSX.IntrinsicElements.span, Decl(react.d.ts, 2461, 51))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution8.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution8.symbols
index 2dec493b886..77243fa9acd 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution8.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution8.symbols
@@ -36,17 +36,17 @@ interface Prop {
 
 class OverWriteAttr extends React.Component<Prop, {}> {
 >OverWriteAttr : Symbol(OverWriteAttr, Decl(file.tsx, 15, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >Prop : Symbol(Prop, Decl(file.tsx, 9, 1))
 
     render() {
 >render : Symbol(OverWriteAttr.render, Decl(file.tsx, 17, 55))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution9.symbols b/tests/baselines/reference/tsxSpreadAttributesResolution9.symbols
index f55b20dfe64..b2461c8d3f5 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution9.symbols
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution9.symbols
@@ -14,17 +14,17 @@ interface OptionProp {
 
 class Opt extends React.Component<OptionProp, {}> {
 >Opt : Symbol(Opt, Decl(file.tsx, 5, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >OptionProp : Symbol(OptionProp, Decl(file.tsx, 0, 32))
 
     render() {
 >render : Symbol(Opt.render, Decl(file.tsx, 7, 51))
 
         return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
     }
 }
 
diff --git a/tests/baselines/reference/tsxSpreadChildren.symbols b/tests/baselines/reference/tsxSpreadChildren.symbols
index 06009e3ca07..b74c28634c3 100644
--- a/tests/baselines/reference/tsxSpreadChildren.symbols
+++ b/tests/baselines/reference/tsxSpreadChildren.symbols
@@ -58,9 +58,9 @@ function TodoList({ todos }: TodoListProps) {
 >div : Symbol(JSX.IntrinsicElements, Decl(tsxSpreadChildren.tsx, 1, 22))
 
         {...todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>)}
->todos.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>todos.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >todos : Symbol(todos, Decl(tsxSpreadChildren.tsx, 18, 19))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >todo : Symbol(todo, Decl(tsxSpreadChildren.tsx, 20, 22))
 >Todo : Symbol(Todo, Decl(tsxSpreadChildren.tsx, 14, 1))
 >key : Symbol(key, Decl(tsxSpreadChildren.tsx, 20, 35))
diff --git a/tests/baselines/reference/tsxSpreadChildren.types b/tests/baselines/reference/tsxSpreadChildren.types
index c762e45b593..4a66e908c49 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: 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.map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
 >todos : TodoProp[]
->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
+>map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
+>todo => <Todo key={todo.id} todo={todo.todo}/> : (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/tsxStatelessFunctionComponentOverload1.js b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.js
index 09eb20c755f..95200b2487d 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.js
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.js
@@ -33,11 +33,11 @@ declare function TestingOptional(a: {y1: boolean, y2?: number, y3: boolean}): JS
 
 // OK
 const e1 = <TestingOptional />
-const e2 = <TestingOptional extra-prop/>
 const e3 = <TestingOptional y1="hello"/>
 const e4 = <TestingOptional y1="hello" y2={1000} />
 const e5 = <TestingOptional y1 y3/>
 const e6 = <TestingOptional y1 y3 y2={10} />
+const e2 = <TestingOptional y1 y3 extra-prop/>
 
 
 
@@ -60,9 +60,9 @@ define(["require", "exports", "react"], function (require, exports, React) {
     var d5 = <TestingOneThing extra-data="hello" yy="hello" name="Bob"/>;
     // OK
     var e1 = <TestingOptional />;
-    var e2 = <TestingOptional extra-prop/>;
     var e3 = <TestingOptional y1="hello"/>;
     var e4 = <TestingOptional y1="hello" y2={1000}/>;
     var e5 = <TestingOptional y1 y3/>;
     var e6 = <TestingOptional y1 y3 y2={10}/>;
+    var e2 = <TestingOptional y1 y3 extra-prop/>;
 });
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.symbols
index 809766f59d3..6946c2b3279 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.symbols
@@ -6,24 +6,24 @@ declare function OneThing(k: {yxx: string}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 57), Decl(file.tsx, 3, 76), Decl(file.tsx, 4, 69), Decl(file.tsx, 5, 83))
 >k : Symbol(k, Decl(file.tsx, 2, 26))
 >yxx : Symbol(yxx, Decl(file.tsx, 2, 30))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OneThing(k: {yxx1: string, children: string}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 57), Decl(file.tsx, 3, 76), Decl(file.tsx, 4, 69), Decl(file.tsx, 5, 83))
 >k : Symbol(k, Decl(file.tsx, 3, 26))
 >yxx1 : Symbol(yxx1, Decl(file.tsx, 3, 30))
 >children : Symbol(children, Decl(file.tsx, 3, 43))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OneThing(l: {yy: number, yy1: string}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 57), Decl(file.tsx, 3, 76), Decl(file.tsx, 4, 69), Decl(file.tsx, 5, 83))
 >l : Symbol(l, Decl(file.tsx, 4, 26))
 >yy : Symbol(yy, Decl(file.tsx, 4, 30))
 >yy1 : Symbol(yy1, Decl(file.tsx, 4, 41))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OneThing(l: {yy: number, yy1: string, yy2: boolean}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 57), Decl(file.tsx, 3, 76), Decl(file.tsx, 4, 69), Decl(file.tsx, 5, 83))
@@ -31,15 +31,15 @@ declare function OneThing(l: {yy: number, yy1: string, yy2: boolean}): JSX.Eleme
 >yy : Symbol(yy, Decl(file.tsx, 5, 30))
 >yy1 : Symbol(yy1, Decl(file.tsx, 5, 41))
 >yy2 : Symbol(yy2, Decl(file.tsx, 5, 54))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OneThing(l1: {data: string, "data-prop": boolean}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 57), Decl(file.tsx, 3, 76), Decl(file.tsx, 4, 69), Decl(file.tsx, 5, 83))
 >l1 : Symbol(l1, Decl(file.tsx, 6, 26))
 >data : Symbol(data, Decl(file.tsx, 6, 31))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 const c1 = <OneThing yxx='ok' />
@@ -76,31 +76,31 @@ declare function TestingOneThing({y1: string}): JSX.Element;
 >TestingOneThing : Symbol(TestingOneThing, Decl(file.tsx, 13, 47), Decl(file.tsx, 16, 60), Decl(file.tsx, 17, 86), Decl(file.tsx, 18, 83))
 >y1 : Symbol(y1)
 >string : Symbol(string, Decl(file.tsx, 16, 34))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function TestingOneThing(j: {"extra-data": string, yy?: string}): JSX.Element;
 >TestingOneThing : Symbol(TestingOneThing, Decl(file.tsx, 13, 47), Decl(file.tsx, 16, 60), Decl(file.tsx, 17, 86), Decl(file.tsx, 18, 83))
 >j : Symbol(j, Decl(file.tsx, 17, 33))
 >yy : Symbol(yy, Decl(file.tsx, 17, 58))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function TestingOneThing(n: {yy: number, direction?: number}): JSX.Element;
 >TestingOneThing : Symbol(TestingOneThing, Decl(file.tsx, 13, 47), Decl(file.tsx, 16, 60), Decl(file.tsx, 17, 86), Decl(file.tsx, 18, 83))
 >n : Symbol(n, Decl(file.tsx, 18, 33))
 >yy : Symbol(yy, Decl(file.tsx, 18, 37))
 >direction : Symbol(direction, Decl(file.tsx, 18, 48))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function TestingOneThing(n: {yy: string, name: string}): JSX.Element;
 >TestingOneThing : Symbol(TestingOneThing, Decl(file.tsx, 13, 47), Decl(file.tsx, 16, 60), Decl(file.tsx, 17, 86), Decl(file.tsx, 18, 83))
 >n : Symbol(n, Decl(file.tsx, 19, 33))
 >yy : Symbol(yy, Decl(file.tsx, 19, 37))
 >name : Symbol(name, Decl(file.tsx, 19, 48))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 const d1 = <TestingOneThing y1 extra-data />;
@@ -140,8 +140,8 @@ declare function TestingOptional(a: {y1?: string, y2?: number}): JSX.Element;
 >a : Symbol(a, Decl(file.tsx, 29, 33))
 >y1 : Symbol(y1, Decl(file.tsx, 29, 37))
 >y2 : Symbol(y2, Decl(file.tsx, 29, 49))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function TestingOptional(a: {y1: boolean, y2?: number, y3: boolean}): JSX.Element;
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
@@ -149,42 +149,44 @@ declare function TestingOptional(a: {y1: boolean, y2?: number, y3: boolean}): JS
 >y1 : Symbol(y1, Decl(file.tsx, 30, 37))
 >y2 : Symbol(y2, Decl(file.tsx, 30, 49))
 >y3 : Symbol(y3, Decl(file.tsx, 30, 62))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 const e1 = <TestingOptional />
 >e1 : Symbol(e1, Decl(file.tsx, 33, 5))
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
 
-const e2 = <TestingOptional extra-prop/>
->e2 : Symbol(e2, Decl(file.tsx, 34, 5))
->TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
->extra-prop : Symbol(extra-prop, Decl(file.tsx, 34, 27))
-
 const e3 = <TestingOptional y1="hello"/>
->e3 : Symbol(e3, Decl(file.tsx, 35, 5))
+>e3 : Symbol(e3, Decl(file.tsx, 34, 5))
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
->y1 : Symbol(y1, Decl(file.tsx, 35, 27))
+>y1 : Symbol(y1, Decl(file.tsx, 34, 27))
 
 const e4 = <TestingOptional y1="hello" y2={1000} />
->e4 : Symbol(e4, Decl(file.tsx, 36, 5))
+>e4 : Symbol(e4, Decl(file.tsx, 35, 5))
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
->y1 : Symbol(y1, Decl(file.tsx, 36, 27))
->y2 : Symbol(y2, Decl(file.tsx, 36, 38))
+>y1 : Symbol(y1, Decl(file.tsx, 35, 27))
+>y2 : Symbol(y2, Decl(file.tsx, 35, 38))
 
 const e5 = <TestingOptional y1 y3/>
->e5 : Symbol(e5, Decl(file.tsx, 37, 5))
+>e5 : Symbol(e5, Decl(file.tsx, 36, 5))
+>TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
+>y1 : Symbol(y1, Decl(file.tsx, 36, 27))
+>y3 : Symbol(y3, Decl(file.tsx, 36, 30))
+
+const e6 = <TestingOptional y1 y3 y2={10} />
+>e6 : Symbol(e6, Decl(file.tsx, 37, 5))
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
 >y1 : Symbol(y1, Decl(file.tsx, 37, 27))
 >y3 : Symbol(y3, Decl(file.tsx, 37, 30))
+>y2 : Symbol(y2, Decl(file.tsx, 37, 33))
 
-const e6 = <TestingOptional y1 y3 y2={10} />
->e6 : Symbol(e6, Decl(file.tsx, 38, 5))
+const e2 = <TestingOptional y1 y3 extra-prop/>
+>e2 : Symbol(e2, Decl(file.tsx, 38, 5))
 >TestingOptional : Symbol(TestingOptional, Decl(file.tsx, 26, 72), Decl(file.tsx, 29, 77))
 >y1 : Symbol(y1, Decl(file.tsx, 38, 27))
 >y3 : Symbol(y3, Decl(file.tsx, 38, 30))
->y2 : Symbol(y2, Decl(file.tsx, 38, 33))
+>extra-prop : Symbol(extra-prop, Decl(file.tsx, 38, 33))
 
 
 
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.types b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.types
index 875f8018a95..cb1908845dd 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.types
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload1.types
@@ -171,12 +171,6 @@ const e1 = <TestingOptional />
 ><TestingOptional /> : JSX.Element
 >TestingOptional : { (a: { y1?: string; y2?: number; }): JSX.Element; (a: { y1: boolean; y2?: number; y3: boolean; }): JSX.Element; }
 
-const e2 = <TestingOptional extra-prop/>
->e2 : JSX.Element
-><TestingOptional extra-prop/> : JSX.Element
->TestingOptional : { (a: { y1?: string; y2?: number; }): JSX.Element; (a: { y1: boolean; y2?: number; y3: boolean; }): JSX.Element; }
->extra-prop : true
-
 const e3 = <TestingOptional y1="hello"/>
 >e3 : JSX.Element
 ><TestingOptional y1="hello"/> : JSX.Element
@@ -207,5 +201,13 @@ const e6 = <TestingOptional y1 y3 y2={10} />
 >y2 : number
 >10 : 10
 
+const e2 = <TestingOptional y1 y3 extra-prop/>
+>e2 : JSX.Element
+><TestingOptional y1 y3 extra-prop/> : JSX.Element
+>TestingOptional : { (a: { y1?: string; y2?: number; }): JSX.Element; (a: { y1: boolean; y2?: number; y3: boolean; }): JSX.Element; }
+>y1 : true
+>y3 : true
+>extra-prop : true
+
 
 
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload2.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentOverload2.symbols
index 25d17e8a643..ed613618411 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload2.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload2.symbols
@@ -4,16 +4,16 @@ import React = require('react')
 
 declare function OneThing(): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 1, 41))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OneThing(l: {yy: number, yy1: string}): JSX.Element;
 >OneThing : Symbol(OneThing, Decl(file.tsx, 0, 31), Decl(file.tsx, 1, 41))
 >l : Symbol(l, Decl(file.tsx, 2, 26))
 >yy : Symbol(yy, Decl(file.tsx, 2, 30))
 >yy1 : Symbol(yy1, Decl(file.tsx, 2, 41))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 let obj = {
 >obj : Symbol(obj, Decl(file.tsx, 4, 3))
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload3.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentOverload3.symbols
index 6290039388d..37d1ef3ce01 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload3.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload3.symbols
@@ -7,8 +7,8 @@ interface Context {
 }
 declare function ZeroThingOrTwoThing(): JSX.Element;
 >ZeroThingOrTwoThing : Symbol(ZeroThingOrTwoThing, Decl(file.tsx, 2, 1), Decl(file.tsx, 3, 52))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function ZeroThingOrTwoThing(l: {yy: number, yy1: string}, context: Context): JSX.Element;
 >ZeroThingOrTwoThing : Symbol(ZeroThingOrTwoThing, Decl(file.tsx, 2, 1), Decl(file.tsx, 3, 52))
@@ -17,8 +17,8 @@ declare function ZeroThingOrTwoThing(l: {yy: number, yy1: string}, context: Cont
 >yy1 : Symbol(yy1, Decl(file.tsx, 4, 52))
 >context : Symbol(context, Decl(file.tsx, 4, 66))
 >Context : Symbol(Context, Decl(file.tsx, 0, 0))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 let obj2: any;
 >obj2 : Symbol(obj2, Decl(file.tsx, 6, 3))
@@ -55,15 +55,15 @@ declare function ThreeThing(l: {y1: string}): JSX.Element;
 >ThreeThing : Symbol(ThreeThing, Decl(file.tsx, 13, 58), Decl(file.tsx, 15, 58), Decl(file.tsx, 16, 58))
 >l : Symbol(l, Decl(file.tsx, 15, 28))
 >y1 : Symbol(y1, Decl(file.tsx, 15, 32))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function ThreeThing(l: {y2: string}): JSX.Element;
 >ThreeThing : Symbol(ThreeThing, Decl(file.tsx, 13, 58), Decl(file.tsx, 15, 58), Decl(file.tsx, 16, 58))
 >l : Symbol(l, Decl(file.tsx, 16, 28))
 >y2 : Symbol(y2, Decl(file.tsx, 16, 32))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function ThreeThing(l: {yy: number, yy1: string}, context: Context, updater: any): JSX.Element;
 >ThreeThing : Symbol(ThreeThing, Decl(file.tsx, 13, 58), Decl(file.tsx, 15, 58), Decl(file.tsx, 16, 58))
@@ -73,8 +73,8 @@ declare function ThreeThing(l: {yy: number, yy1: string}, context: Context, upda
 >context : Symbol(context, Decl(file.tsx, 17, 57))
 >Context : Symbol(Context, Decl(file.tsx, 0, 0))
 >updater : Symbol(updater, Decl(file.tsx, 17, 75))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 const three1 = <ThreeThing yy={99} yy1="hello world" />;
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentOverload6.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentOverload6.symbols
index c6444484973..cc3cb199309 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentOverload6.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentOverload6.symbols
@@ -19,7 +19,7 @@ export interface ButtonProps extends ClickableProps {
     onClick: React.MouseEventHandler<any>;
 >onClick : Symbol(ButtonProps.onClick, Decl(file.tsx, 7, 53))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->MouseEventHandler : Symbol(React.MouseEventHandler, Decl(react.d.ts, 388, 66))
+>MouseEventHandler : Symbol(React.MouseEventHandler, Decl(react.d.ts, 389, 66))
 }
 
 export interface LinkProps extends ClickableProps {
@@ -60,22 +60,22 @@ export function MainButton(buttonProps: ButtonProps): JSX.Element;
 >MainButton : Symbol(MainButton, Decl(file.tsx, 26, 1), Decl(file.tsx, 28, 66), Decl(file.tsx, 29, 62), Decl(file.tsx, 30, 66))
 >buttonProps : Symbol(buttonProps, Decl(file.tsx, 28, 27))
 >ButtonProps : Symbol(ButtonProps, Decl(file.tsx, 5, 1))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 export function MainButton(linkProps: LinkProps): JSX.Element;
 >MainButton : Symbol(MainButton, Decl(file.tsx, 26, 1), Decl(file.tsx, 28, 66), Decl(file.tsx, 29, 62), Decl(file.tsx, 30, 66))
 >linkProps : Symbol(linkProps, Decl(file.tsx, 29, 27))
 >LinkProps : Symbol(LinkProps, Decl(file.tsx, 9, 1))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 export function MainButton(hyphenProps: HyphenProps): JSX.Element;
 >MainButton : Symbol(MainButton, Decl(file.tsx, 26, 1), Decl(file.tsx, 28, 66), Decl(file.tsx, 29, 62), Decl(file.tsx, 30, 66))
 >hyphenProps : Symbol(hyphenProps, Decl(file.tsx, 30, 27))
 >HyphenProps : Symbol(HyphenProps, Decl(file.tsx, 13, 1))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 export function MainButton(props: ButtonProps | LinkProps | HyphenProps): JSX.Element {
 >MainButton : Symbol(MainButton, Decl(file.tsx, 26, 1), Decl(file.tsx, 28, 66), Decl(file.tsx, 29, 62), Decl(file.tsx, 30, 66))
@@ -83,8 +83,8 @@ export function MainButton(props: ButtonProps | LinkProps | HyphenProps): JSX.El
 >ButtonProps : Symbol(ButtonProps, Decl(file.tsx, 5, 1))
 >LinkProps : Symbol(LinkProps, Decl(file.tsx, 9, 1))
 >HyphenProps : Symbol(HyphenProps, Decl(file.tsx, 13, 1))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
     const linkProps = props as LinkProps;
 >linkProps : Symbol(linkProps, Decl(file.tsx, 32, 9))
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter1.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter1.symbols
index 3cc5e4b3000..f1973b1cc09 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter1.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter1.symbols
@@ -17,8 +17,8 @@ function MyComponent<T = MyComponentProp>(attr: T) {
 >T : Symbol(T, Decl(file.tsx, 6, 21))
 
     return <div>attr.values</div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 // OK
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
index 243f29493bf..91d735bb9ed 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponents1.errors.txt
@@ -5,16 +5,17 @@ tests/cases/conformance/jsx/file.tsx(27,15): error TS2322: Type '{ name: 42; }'
   Type '{ name: 42; }' is not assignable to type '{ name?: string; }'.
     Types of property 'name' are incompatible.
       Type '42' is not assignable to type 'string'.
-tests/cases/conformance/jsx/file.tsx(29,15): error TS2339: Property 'naaaaaaame' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
+tests/cases/conformance/jsx/file.tsx(29,15): error TS2559: Type '{ naaaaaaame: "no"; }' has no properties in common with type 'IntrinsicAttributes & { name?: string; }'.
 tests/cases/conformance/jsx/file.tsx(34,23): error TS2322: Type '{}' is not assignable to type 'IntrinsicAttributes & { "prop-name": string; }'.
   Type '{}' is not assignable to type '{ "prop-name": string; }'.
     Property '"prop-name"' is missing in type '{}'.
-tests/cases/conformance/jsx/file.tsx(37,23): error TS2339: Property 'prop1' does not exist on type 'IntrinsicAttributes'.
-tests/cases/conformance/jsx/file.tsx(38,24): error TS2339: Property 'ref' does not exist on type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(37,23): error TS2559: Type '{ prop1: true; }' has no properties in common with type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(38,24): error TS2559: Type '{ ref: (x: any) => any; }' has no properties in common with type 'IntrinsicAttributes'.
 tests/cases/conformance/jsx/file.tsx(41,16): error TS1005: ',' expected.
+tests/cases/conformance/jsx/file.tsx(45,24): error TS2559: Type '{ prop1: boolean; }' has no properties in common with type 'IntrinsicAttributes'.
 
 
-==== tests/cases/conformance/jsx/file.tsx (7 errors) ====
+==== tests/cases/conformance/jsx/file.tsx (8 errors) ====
     function EmptyPropSFC() {
         return <div> Default Greeting </div>;
     }
@@ -54,7 +55,7 @@ tests/cases/conformance/jsx/file.tsx(41,16): error TS1005: ',' expected.
     // Error
     let f = <Meet naaaaaaame='no' />;
                   ~~~~~~~~~~~~~~~
-!!! error TS2339: Property 'naaaaaaame' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
+!!! error TS2559: Type '{ naaaaaaame: "no"; }' has no properties in common with type 'IntrinsicAttributes & { name?: string; }'.
     
     // OK
     let g = <MeetAndGreet prop-name="Bob" />;
@@ -68,10 +69,10 @@ tests/cases/conformance/jsx/file.tsx(41,16): error TS1005: ',' expected.
     // Error
     let i = <EmptyPropSFC prop1 />
                           ~~~~~
-!!! error TS2339: Property 'prop1' does not exist on type 'IntrinsicAttributes'.
+!!! error TS2559: Type '{ prop1: true; }' has no properties in common with type 'IntrinsicAttributes'.
     let i1 = <EmptyPropSFC ref={x => x.greeting.substr(10)} />
                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2339: Property 'ref' does not exist on type 'IntrinsicAttributes'.
+!!! error TS2559: Type '{ ref: (x: any) => any; }' has no properties in common with type 'IntrinsicAttributes'.
     
     let o = {
         prop1: true;
@@ -81,6 +82,8 @@ tests/cases/conformance/jsx/file.tsx(41,16): error TS1005: ',' expected.
     
     // OK as access properties are allow when spread
     let i2 = <EmptyPropSFC {...o} />
+                           ~~~~~~
+!!! error TS2559: Type '{ prop1: boolean; }' has no properties in common with type 'IntrinsicAttributes'.
     
     let o1: any;
     // OK
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
index 00e2c4a526c..1e7a29c3378 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponents2.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(19,16): error TS2339: Property 'ref' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
+tests/cases/conformance/jsx/file.tsx(19,16): error TS2559: Type '{ ref: "myRef"; }' has no properties in common with type 'IntrinsicAttributes & { name?: string; }'.
 tests/cases/conformance/jsx/file.tsx(25,42): error TS2339: Property 'subtr' does not exist on type 'string'.
 tests/cases/conformance/jsx/file.tsx(27,33): error TS2339: Property 'notARealProperty' does not exist on type 'BigGreeter'.
 tests/cases/conformance/jsx/file.tsx(35,26): error TS2339: Property 'propertyNotOnHtmlDivElement' does not exist on type 'HTMLDivElement'.
@@ -25,7 +25,7 @@ tests/cases/conformance/jsx/file.tsx(35,26): error TS2339: Property 'propertyNot
     // Error - not allowed to specify 'ref' on SFCs
     let c = <Greet ref="myRef" />;
                    ~~~~~~~~~~~
-!!! error TS2339: Property 'ref' does not exist on type 'IntrinsicAttributes & { name?: string; }'.
+!!! error TS2559: Type '{ ref: "myRef"; }' has no properties in common with type 'IntrinsicAttributes & { name?: string; }'.
     
     
     // OK - ref is valid for classes
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponents3.symbols b/tests/baselines/reference/tsxStatelessFunctionComponents3.symbols
index a18da7954bc..a2809f18458 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponents3.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponents3.symbols
@@ -5,7 +5,7 @@ import React = require('react');
 const Foo = (props: any) => <div/>;
 >Foo : Symbol(Foo, Decl(file.tsx, 2, 5))
 >props : Symbol(props, Decl(file.tsx, 2, 13))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 // Should be OK
 const foo = <Foo />;
@@ -17,31 +17,31 @@ const foo = <Foo />;
 var MainMenu: React.StatelessComponent<{}> = (props) => (<div>
 >MainMenu : Symbol(MainMenu, Decl(file.tsx, 8, 3))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >props : Symbol(props, Decl(file.tsx, 8, 46))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     <h3>Main Menu</h3>
->h3 : Symbol(JSX.IntrinsicElements.h3, Decl(react.d.ts, 2411, 48))
->h3 : Symbol(JSX.IntrinsicElements.h3, Decl(react.d.ts, 2411, 48))
+>h3 : Symbol(JSX.IntrinsicElements.h3, Decl(react.d.ts, 2412, 48))
+>h3 : Symbol(JSX.IntrinsicElements.h3, Decl(react.d.ts, 2412, 48))
 
 </div>);
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 var App: React.StatelessComponent<{ children }> = ({children}) => (
 >App : Symbol(App, Decl(file.tsx, 12, 3))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >children : Symbol(children, Decl(file.tsx, 12, 35))
 >children : Symbol(children, Decl(file.tsx, 12, 52))
 
     <div >
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
         <MainMenu/>
 >MainMenu : Symbol(MainMenu, Decl(file.tsx, 8, 3))
 
 	</div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 );
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments1.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments1.symbols
index 0e972a36c43..5070ccaf5c3 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments1.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments1.symbols
@@ -11,8 +11,8 @@ declare function ComponentWithTwoAttributes<K,V>(l: {key1: K, value: V}): JSX.El
 >K : Symbol(K, Decl(file.tsx, 2, 44))
 >value : Symbol(value, Decl(file.tsx, 2, 61))
 >V : Symbol(V, Decl(file.tsx, 2, 46))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 function Baz<T,U>(key1: T, value: U) {
@@ -48,8 +48,8 @@ declare function Link<U>(l: {func: (arg: U)=>void}): JSX.Element;
 >func : Symbol(func, Decl(file.tsx, 10, 29))
 >arg : Symbol(arg, Decl(file.tsx, 10, 36))
 >U : Symbol(U, Decl(file.tsx, 10, 22))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 function createLink(func: (a: number)=>void) {
@@ -97,8 +97,8 @@ declare function InferParamComponent<T>(attr: InferParamProp<T>): JSX.Element;
 >attr : Symbol(attr, Decl(file.tsx, 26, 40))
 >InferParamProp : Symbol(InferParamProp, Decl(file.tsx, 19, 1))
 >T : Symbol(T, Decl(file.tsx, 26, 37))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 let i = <InferParamComponent values={[1, 2, 3, 4]} selectHandler={(val) => { }} />;
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.symbols b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.symbols
index e93eb374aa7..b0823c19d67 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.symbols
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments3.symbols
@@ -5,8 +5,8 @@ import React = require('react')
 declare function OverloadComponent<U>(): JSX.Element;
 >OverloadComponent : Symbol(OverloadComponent, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 53), Decl(file.tsx, 3, 101))
 >U : Symbol(U, Decl(file.tsx, 2, 35))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OverloadComponent<U>(attr: {b: U, a?: string, "ignore-prop": boolean}): JSX.Element;
 >OverloadComponent : Symbol(OverloadComponent, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 53), Decl(file.tsx, 3, 101))
@@ -15,8 +15,8 @@ declare function OverloadComponent<U>(attr: {b: U, a?: string, "ignore-prop": bo
 >b : Symbol(b, Decl(file.tsx, 3, 45))
 >U : Symbol(U, Decl(file.tsx, 3, 35))
 >a : Symbol(a, Decl(file.tsx, 3, 50))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function OverloadComponent<T, U>(attr: {b: U, a: T}): JSX.Element;
 >OverloadComponent : Symbol(OverloadComponent, Decl(file.tsx, 0, 31), Decl(file.tsx, 2, 53), Decl(file.tsx, 3, 101))
@@ -27,8 +27,8 @@ declare function OverloadComponent<T, U>(attr: {b: U, a: T}): JSX.Element;
 >U : Symbol(U, Decl(file.tsx, 4, 37))
 >a : Symbol(a, Decl(file.tsx, 4, 53))
 >T : Symbol(T, Decl(file.tsx, 4, 35))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 // OK
 function Baz<T extends {b: number}, U extends {a: boolean, b:string}>(arg1: T, arg2: U) {
@@ -93,8 +93,8 @@ declare function Link<U>(l: {func: (arg: U)=>void}): JSX.Element;
 >func : Symbol(func, Decl(file.tsx, 17, 29))
 >arg : Symbol(arg, Decl(file.tsx, 17, 36))
 >U : Symbol(U, Decl(file.tsx, 17, 22))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 declare function Link<U>(l: {func: (arg1:U, arg2: string)=>void}): JSX.Element;
 >Link : Symbol(Link, Decl(file.tsx, 15, 1), Decl(file.tsx, 17, 65))
@@ -104,8 +104,8 @@ declare function Link<U>(l: {func: (arg1:U, arg2: string)=>void}): JSX.Element;
 >arg1 : Symbol(arg1, Decl(file.tsx, 18, 36))
 >U : Symbol(U, Decl(file.tsx, 18, 22))
 >arg2 : Symbol(arg2, Decl(file.tsx, 18, 43))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 
 function createLink(func: (a: number)=>void) {
 >createLink : Symbol(createLink, Decl(file.tsx, 18, 79))
diff --git a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.errors.txt b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.errors.txt
index 311cfaed86f..2feed16ac0a 100644
--- a/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.errors.txt
+++ b/tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.errors.txt
@@ -4,9 +4,9 @@ tests/cases/conformance/jsx/file.tsx(9,33): error TS2322: Type '{ a: number; }'
 tests/cases/conformance/jsx/file.tsx(10,33): error TS2322: Type 'T' is not assignable to type 'IntrinsicAttributes & { b: number; a: {}; }'.
   Type '{ b: number; }' is not assignable to type 'IntrinsicAttributes & { b: number; a: {}; }'.
     Type '{ b: number; }' is not assignable to type '{ b: number; a: {}; }'.
-      Type 'T' is not assignable to type '{ b: number; a: {}; }'.
-        Type '{ b: number; }' is not assignable to type '{ b: number; a: {}; }'.
-          Property 'a' is missing in type '{ b: number; }'.
+      Property 'a' is missing in type '{ b: number; }'.
+        Type 'T' is not assignable to type 'IntrinsicAttributes'.
+          Type '{ b: number; }' has no properties in common with type 'IntrinsicAttributes'.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (2 errors) ====
@@ -28,7 +28,7 @@ tests/cases/conformance/jsx/file.tsx(10,33): error TS2322: Type 'T' is not assig
 !!! error TS2322: Type 'T' is not assignable to type 'IntrinsicAttributes & { b: number; a: {}; }'.
 !!! error TS2322:   Type '{ b: number; }' is not assignable to type 'IntrinsicAttributes & { b: number; a: {}; }'.
 !!! error TS2322:     Type '{ b: number; }' is not assignable to type '{ b: number; a: {}; }'.
-!!! error TS2322:       Type 'T' is not assignable to type '{ b: number; a: {}; }'.
-!!! error TS2322:         Type '{ b: number; }' is not assignable to type '{ b: number; a: {}; }'.
-!!! error TS2322:           Property 'a' is missing in type '{ b: number; }'.
+!!! error TS2322:       Property 'a' is missing in type '{ b: number; }'.
+!!! error TS2322:         Type 'T' is not assignable to type 'IntrinsicAttributes'.
+!!! error TS2322:           Type '{ b: number; }' has no properties in common with type 'IntrinsicAttributes'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxUnionElementType1.symbols b/tests/baselines/reference/tsxUnionElementType1.symbols
index 728e559ee65..8a53907ea6e 100644
--- a/tests/baselines/reference/tsxUnionElementType1.symbols
+++ b/tests/baselines/reference/tsxUnionElementType1.symbols
@@ -8,8 +8,8 @@ function SFC1(prop: { x: number }) {
 >x : Symbol(x, Decl(file.tsx, 2, 21))
 
     return <div>hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
 };
 
@@ -19,8 +19,8 @@ function SFC2(prop: { x: boolean }) {
 >x : Symbol(x, Decl(file.tsx, 6, 21))
 
     return <h1>World </h1>;
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 }
 
 var SFCComp = SFC1 || SFC2;
diff --git a/tests/baselines/reference/tsxUnionElementType3.symbols b/tests/baselines/reference/tsxUnionElementType3.symbols
index 05fe89a77e8..875294d6f6e 100644
--- a/tests/baselines/reference/tsxUnionElementType3.symbols
+++ b/tests/baselines/reference/tsxUnionElementType3.symbols
@@ -4,9 +4,9 @@ import React = require('react');
 
 class RC1 extends React.Component<{x : number}, {}> {
 >RC1 : Symbol(RC1, Decl(file.tsx, 0, 32))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >x : Symbol(x, Decl(file.tsx, 2, 35))
 
     render() {
@@ -18,9 +18,9 @@ class RC1 extends React.Component<{x : number}, {}> {
 
 class RC2 extends React.Component<{ x: string }, {}> {
 >RC2 : Symbol(RC2, Decl(file.tsx, 6, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >x : Symbol(x, Decl(file.tsx, 8, 35))
 
     render() {
@@ -34,9 +34,9 @@ class RC2 extends React.Component<{ x: string }, {}> {
 
 class RC3 extends React.Component<{}, {}> {
 >RC3 : Symbol(RC3, Decl(file.tsx, 13, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(RC3.render, Decl(file.tsx, 15, 43))
@@ -47,9 +47,9 @@ class RC3 extends React.Component<{}, {}> {
 
 class RC4 extends React.Component<{}, {}> {
 >RC4 : Symbol(RC4, Decl(file.tsx, 19, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 
     render() {
 >render : Symbol(RC4.render, Decl(file.tsx, 21, 43))
diff --git a/tests/baselines/reference/tsxUnionElementType4.errors.txt b/tests/baselines/reference/tsxUnionElementType4.errors.txt
index 4658b566cc7..3e0f625c4d3 100644
--- a/tests/baselines/reference/tsxUnionElementType4.errors.txt
+++ b/tests/baselines/reference/tsxUnionElementType4.errors.txt
@@ -3,8 +3,8 @@ tests/cases/conformance/jsx/file.tsx(32,17): error TS2322: Type '{ x: true; }' i
     Type '{ x: true; }' is not assignable to type '{ x: string; }'.
       Types of property 'x' are incompatible.
         Type 'true' is not assignable to type 'string'.
-tests/cases/conformance/jsx/file.tsx(33,21): error TS2339: Property 'x' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
-tests/cases/conformance/jsx/file.tsx(34,22): error TS2339: Property 'prop' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(33,21): error TS2559: Type '{ x: 10; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
+tests/cases/conformance/jsx/file.tsx(34,22): error TS2559: Type '{ prop: true; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
 
 
 ==== tests/cases/conformance/jsx/file.tsx (3 errors) ====
@@ -48,8 +48,8 @@ tests/cases/conformance/jsx/file.tsx(34,22): error TS2339: Property 'prop' does
 !!! error TS2322:         Type 'true' is not assignable to type 'string'.
     let b = <PartRCComp x={10} />
                         ~~~~~~
-!!! error TS2339: Property 'x' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
+!!! error TS2559: Type '{ x: 10; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<RC4> & { children?: ReactNode; }'.
     let c = <EmptyRCComp prop />;
                          ~~~~
-!!! error TS2339: Property 'prop' does not exist on type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
+!!! error TS2559: Type '{ prop: true; }' has no properties in common with type 'IntrinsicAttributes & IntrinsicClassAttributes<RC3> & { children?: ReactNode; }'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxUnionElementType5.symbols b/tests/baselines/reference/tsxUnionElementType5.symbols
index 9a5e94f69a3..2ac4800ac5b 100644
--- a/tests/baselines/reference/tsxUnionElementType5.symbols
+++ b/tests/baselines/reference/tsxUnionElementType5.symbols
@@ -6,16 +6,16 @@ function EmptySFC1() {
 >EmptySFC1 : Symbol(EmptySFC1, Decl(file.tsx, 0, 32))
 
     return <div>hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 function EmptySFC2() {
 >EmptySFC2 : Symbol(EmptySFC2, Decl(file.tsx, 4, 1))
 
     return <div>Hello</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 function SFC2(prop: { x: boolean }) {
@@ -24,8 +24,8 @@ function SFC2(prop: { x: boolean }) {
 >x : Symbol(x, Decl(file.tsx, 10, 21))
 
     return <h1>World</h1>;
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
->h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2409, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47))
 }
 
 var EmptySFCComp = EmptySFC1 || EmptySFC2;
diff --git a/tests/baselines/reference/tsxUnionElementType6.errors.txt b/tests/baselines/reference/tsxUnionElementType6.errors.txt
index cac96565b80..854a84eb85e 100644
--- a/tests/baselines/reference/tsxUnionElementType6.errors.txt
+++ b/tests/baselines/reference/tsxUnionElementType6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/jsx/file.tsx(18,23): error TS2339: Property 'x' does not exist on type 'IntrinsicAttributes'.
+tests/cases/conformance/jsx/file.tsx(18,23): error TS2559: Type '{ x: true; }' has no properties in common with type 'IntrinsicAttributes'.
 tests/cases/conformance/jsx/file.tsx(19,27): error TS2322: Type '{ x: "hi"; }' is not assignable to type 'IntrinsicAttributes & { x: boolean; }'.
   Type '{ x: "hi"; }' is not assignable to type '{ x: boolean; }'.
     Types of property 'x' are incompatible.
@@ -31,7 +31,7 @@ tests/cases/conformance/jsx/file.tsx(21,27): error TS2322: Type '{}' is not assi
     // Error
     let a = <EmptySFCComp x />;
                           ~
-!!! error TS2339: Property 'x' does not exist on type 'IntrinsicAttributes'.
+!!! error TS2559: Type '{ x: true; }' has no properties in common with type 'IntrinsicAttributes'.
     let b = <SFC2AndEmptyComp x="hi" />;
                               ~~~~~~
 !!! error TS2322: Type '{ x: "hi"; }' is not assignable to type 'IntrinsicAttributes & { x: boolean; }'.
diff --git a/tests/baselines/reference/tsxUnionTypeComponent1.symbols b/tests/baselines/reference/tsxUnionTypeComponent1.symbols
index 4af712bf3fc..9a8219e1232 100644
--- a/tests/baselines/reference/tsxUnionTypeComponent1.symbols
+++ b/tests/baselines/reference/tsxUnionTypeComponent1.symbols
@@ -8,16 +8,16 @@ interface ComponentProps {
     AnyComponent: React.StatelessComponent<any> | React.ComponentClass<any>;
 >AnyComponent : Symbol(ComponentProps.AnyComponent, Decl(file.tsx, 2, 26))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 197, 40))
+>StatelessComponent : Symbol(React.StatelessComponent, Decl(react.d.ts, 198, 40))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->ComponentClass : Symbol(React.ComponentClass, Decl(react.d.ts, 204, 5))
+>ComponentClass : Symbol(React.ComponentClass, Decl(react.d.ts, 205, 5))
 }
 
 class MyComponent extends React.Component<ComponentProps, {}> {
 >MyComponent : Symbol(MyComponent, Decl(file.tsx, 4, 1))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >ComponentProps : Symbol(ComponentProps, Decl(file.tsx, 0, 32))
 
     render() {
@@ -25,9 +25,9 @@ class MyComponent extends React.Component<ComponentProps, {}> {
 
         const { AnyComponent } = this.props;
 >AnyComponent : Symbol(AnyComponent, Decl(file.tsx, 8, 15))
->this.props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 >this : Symbol(MyComponent, Decl(file.tsx, 4, 1))
->props : Symbol(React.Component.props, Decl(react.d.ts, 166, 37))
+>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37))
 
         return (<AnyComponent />);
 >AnyComponent : Symbol(AnyComponent, Decl(file.tsx, 8, 15))
@@ -38,15 +38,15 @@ class MyComponent extends React.Component<ComponentProps, {}> {
 <MyComponent AnyComponent={() => <button>test</button>}/>
 >MyComponent : Symbol(MyComponent, Decl(file.tsx, 4, 1))
 >AnyComponent : Symbol(AnyComponent, Decl(file.tsx, 14, 12))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
->button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2385, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
+>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43))
 
 // Component Class as Props
 class MyButtonComponent extends React.Component<{},{}> {
 >MyButtonComponent : Symbol(MyButtonComponent, Decl(file.tsx, 14, 57))
->React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 >React : Symbol(React, Decl(file.tsx, 0, 0))
->Component : Symbol(React.Component, Decl(react.d.ts, 158, 55))
+>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66))
 }
 
 <MyComponent AnyComponent={MyButtonComponent} />
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
index d294a9c28cf..b73bd8882d2 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
@@ -15,9 +15,9 @@ var nodes: TreeNode[];
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0))
 
 nodes.map(n => n.name);
->nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 5, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
 >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
index 518bf14d010..5269bd9b518 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: 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.map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
 >nodes : TreeNode[]
->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
+>map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
+>n => n.name : (n: TreeNode) => string
 >n : TreeNode
 >n.name : string
 >n : TreeNode
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
index 3761994619c..7cec46cb4b6 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
@@ -26,9 +26,9 @@ var nodes: TreeNodeMiddleman[];
 >TreeNodeMiddleman : Symbol(TreeNodeMiddleman, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 3, 1))
 
 nodes.map(n => n.name);
->nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 10, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
 >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
index 45054ed6aa0..59244850849 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: 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.map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
 >nodes : TreeNodeMiddleman[]
->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
+>map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
+>n => n.name : (n: TreeNodeMiddleman) => string
 >n : TreeNodeMiddleman
 >n.name : string
 >n : TreeNodeMiddleman
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index a5f51ffda9c..f3f0aca48c3 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -166,65 +166,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     return typedArrays;
@@ -241,65 +241,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     return typedArrays;
@@ -457,73 +457,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
@@ -545,81 +545,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
diff --git a/tests/baselines/reference/typedArrays.types b/tests/baselines/reference/typedArrays.types
index 259d601d426..99c7e433ea5 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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: 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; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): 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/unreachableJavascriptChecked.errors.txt b/tests/baselines/reference/unreachableJavascriptChecked.errors.txt
new file mode 100644
index 00000000000..c66b342177f
--- /dev/null
+++ b/tests/baselines/reference/unreachableJavascriptChecked.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/compiler/unreachable.js(3,5): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/compiler/unreachable.js (1 errors) ====
+    function unreachable() {
+        return 1;
+        return 2;
+        ~~~~~~
+!!! error TS7027: Unreachable code detected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/unreachableJavascriptChecked.js b/tests/baselines/reference/unreachableJavascriptChecked.js
new file mode 100644
index 00000000000..6bf264bf3d2
--- /dev/null
+++ b/tests/baselines/reference/unreachableJavascriptChecked.js
@@ -0,0 +1,11 @@
+//// [unreachable.js]
+function unreachable() {
+    return 1;
+    return 2;
+}
+
+//// [unreachable.js]
+function unreachable() {
+    return 1;
+    return 2;
+}
diff --git a/tests/baselines/reference/unreachableJavascriptUnchecked.js b/tests/baselines/reference/unreachableJavascriptUnchecked.js
new file mode 100644
index 00000000000..6bf264bf3d2
--- /dev/null
+++ b/tests/baselines/reference/unreachableJavascriptUnchecked.js
@@ -0,0 +1,11 @@
+//// [unreachable.js]
+function unreachable() {
+    return 1;
+    return 2;
+}
+
+//// [unreachable.js]
+function unreachable() {
+    return 1;
+    return 2;
+}
diff --git a/tests/baselines/reference/unreachableJavascriptUnchecked.symbols b/tests/baselines/reference/unreachableJavascriptUnchecked.symbols
new file mode 100644
index 00000000000..f2db6a6a347
--- /dev/null
+++ b/tests/baselines/reference/unreachableJavascriptUnchecked.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/unreachable.js ===
+function unreachable() {
+>unreachable : Symbol(unreachable, Decl(unreachable.js, 0, 0))
+
+    return 1;
+    return 2;
+}
diff --git a/tests/baselines/reference/unreachableJavascriptUnchecked.types b/tests/baselines/reference/unreachableJavascriptUnchecked.types
new file mode 100644
index 00000000000..266a9038875
--- /dev/null
+++ b/tests/baselines/reference/unreachableJavascriptUnchecked.types
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/unreachable.js ===
+function unreachable() {
+>unreachable : () => 1 | 2
+
+    return 1;
+>1 : 1
+
+    return 2;
+>2 : 2
+}
diff --git a/tests/baselines/reference/weakType.errors.txt b/tests/baselines/reference/weakType.errors.txt
new file mode 100644
index 00000000000..7064ace5daa
--- /dev/null
+++ b/tests/baselines/reference/weakType.errors.txt
@@ -0,0 +1,72 @@
+tests/cases/compiler/weakType.ts(31,18): error TS2559: Type '{ error?: number; }' has no properties in common with type 'ChangeOptions'.
+tests/cases/compiler/weakType.ts(56,5): error TS2322: Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak & Spoiler'.
+  Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak'.
+    Types of property 'properties' are incompatible.
+      Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
+
+
+==== tests/cases/compiler/weakType.ts (2 errors) ====
+    interface Settings {
+        timeout?: number;
+        onError?(): void;
+    }
+    
+    function getDefaultSettings() {
+        return { timeout: 1000 };
+    }
+    
+    function doSomething(settings: Settings) { /* ... */ }
+    
+    // forgot to call `getDefaultSettings`
+    // but it is not caught because we don't check for call signatures
+    doSomething(getDefaultSettings);
+    
+    // this is an oddly popular way of defining settings
+    // this example is from services/textChanges.ts
+    type ConfigurableStart = { useStart?: boolean }
+    type ConfigurableEnd = { useEnd?: boolean }
+    type ConfigurableStartEnd = ConfigurableStart & ConfigurableEnd
+    interface InsertOptions {
+        prefix?: string
+        suffix?: string
+    }
+    type ChangeOptions = ConfigurableStartEnd & InsertOptions;
+    
+    function del(options: ConfigurableStartEnd = {},
+                 error: { error?: number } = {}) {
+        let changes: ChangeOptions[];
+        changes.push(options);
+        changes.push(error);
+                     ~~~~~
+!!! error TS2559: Type '{ error?: number; }' has no properties in common with type 'ChangeOptions'.
+    }
+    
+    class K {
+        constructor(s: string) { }
+    }
+    // Ctor isn't a weak type because it has a construct signature
+    interface Ctor {
+        new (s: string): K
+        n?: number
+    }
+    let ctor: Ctor = K
+    
+    type Spoiler = { nope?: string }
+    type Weak = {
+        a?: number
+        properties?: {
+            b?: number
+        }
+    }
+    declare let unknown: {
+        properties: {
+            wrong: string
+        }
+    }
+    let weak: Weak & Spoiler = unknown
+        ~~~~
+!!! error TS2322: Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak & Spoiler'.
+!!! error TS2322:   Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak'.
+!!! error TS2322:     Types of property 'properties' are incompatible.
+!!! error TS2322:       Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/weakType.js b/tests/baselines/reference/weakType.js
new file mode 100644
index 00000000000..6ed3ff1814d
--- /dev/null
+++ b/tests/baselines/reference/weakType.js
@@ -0,0 +1,81 @@
+//// [weakType.ts]
+interface Settings {
+    timeout?: number;
+    onError?(): void;
+}
+
+function getDefaultSettings() {
+    return { timeout: 1000 };
+}
+
+function doSomething(settings: Settings) { /* ... */ }
+
+// forgot to call `getDefaultSettings`
+// but it is not caught because we don't check for call signatures
+doSomething(getDefaultSettings);
+
+// this is an oddly popular way of defining settings
+// this example is from services/textChanges.ts
+type ConfigurableStart = { useStart?: boolean }
+type ConfigurableEnd = { useEnd?: boolean }
+type ConfigurableStartEnd = ConfigurableStart & ConfigurableEnd
+interface InsertOptions {
+    prefix?: string
+    suffix?: string
+}
+type ChangeOptions = ConfigurableStartEnd & InsertOptions;
+
+function del(options: ConfigurableStartEnd = {},
+             error: { error?: number } = {}) {
+    let changes: ChangeOptions[];
+    changes.push(options);
+    changes.push(error);
+}
+
+class K {
+    constructor(s: string) { }
+}
+// Ctor isn't a weak type because it has a construct signature
+interface Ctor {
+    new (s: string): K
+    n?: number
+}
+let ctor: Ctor = K
+
+type Spoiler = { nope?: string }
+type Weak = {
+    a?: number
+    properties?: {
+        b?: number
+    }
+}
+declare let unknown: {
+    properties: {
+        wrong: string
+    }
+}
+let weak: Weak & Spoiler = unknown
+
+
+//// [weakType.js]
+function getDefaultSettings() {
+    return { timeout: 1000 };
+}
+function doSomething(settings) { }
+// forgot to call `getDefaultSettings`
+// but it is not caught because we don't check for call signatures
+doSomething(getDefaultSettings);
+function del(options, error) {
+    if (options === void 0) { options = {}; }
+    if (error === void 0) { error = {}; }
+    var changes;
+    changes.push(options);
+    changes.push(error);
+}
+var K = (function () {
+    function K(s) {
+    }
+    return K;
+}());
+var ctor = K;
+var weak = unknown;
diff --git a/tests/cases/compiler/APISample_watcher.ts b/tests/cases/compiler/APISample_watcher.ts
index 3e8ce3d8d63..436a1401d57 100644
--- a/tests/cases/compiler/APISample_watcher.ts
+++ b/tests/cases/compiler/APISample_watcher.ts
@@ -15,7 +15,7 @@ declare var fs: {
     existsSync(path: string): boolean;
     readdirSync(path: string): string[];
     readFileSync(filename: string, encoding?: string): string;
-    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; } | string): void;
     watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: { mtime: Date }, prev: { mtime: Date }) => void): void;
 };
 declare var path: any;
diff --git a/tests/cases/compiler/blockScopedClassDeclarationAcrossFiles.ts b/tests/cases/compiler/blockScopedClassDeclarationAcrossFiles.ts
new file mode 100644
index 00000000000..16827602308
--- /dev/null
+++ b/tests/cases/compiler/blockScopedClassDeclarationAcrossFiles.ts
@@ -0,0 +1,5 @@
+// @outFile: foo.js
+// @Filename: c.ts
+let foo: typeof C;
+// @Filename: b.ts
+class C { }
diff --git a/tests/cases/compiler/exactSpellingSuggestion.ts b/tests/cases/compiler/exactSpellingSuggestion.ts
new file mode 100644
index 00000000000..99aec9a0199
--- /dev/null
+++ b/tests/cases/compiler/exactSpellingSuggestion.ts
@@ -0,0 +1,9 @@
+// Fixes #16245 -- always suggest the exact match, even when
+// other options are very close
+enum U8 {
+    BIT_0 = 1 << 0,
+    BIT_1 = 1 << 1,
+    BIT_2 = 1 << 2
+}
+
+U8.bit_2
diff --git a/tests/cases/compiler/jsFileCompilationBindDuplicateIdentifier.ts b/tests/cases/compiler/jsFileCompilationBindDuplicateIdentifier.ts
index 3433adc17d5..7659350d489 100644
--- a/tests/cases/compiler/jsFileCompilationBindDuplicateIdentifier.ts
+++ b/tests/cases/compiler/jsFileCompilationBindDuplicateIdentifier.ts
@@ -1,4 +1,5 @@
 // @allowJs: true
+// @checkJs: true
 // @noEmit: true
 // @filename: a.js
 var a = 10;
diff --git a/tests/cases/compiler/jsFileCompilationBindErrors.ts b/tests/cases/compiler/jsFileCompilationBindErrors.ts
index 37bdbc62916..7c43b329a47 100644
--- a/tests/cases/compiler/jsFileCompilationBindErrors.ts
+++ b/tests/cases/compiler/jsFileCompilationBindErrors.ts
@@ -1,4 +1,5 @@
 // @allowJs: true
+// @checkJs: true
 // @noEmit: true
 // @filename: a.js
 let C = "sss";
diff --git a/tests/cases/compiler/jsFileCompilationBindMultipleDefaultExports.ts b/tests/cases/compiler/jsFileCompilationBindMultipleDefaultExports.ts
index 32a9e77fcc7..e7816f92ad1 100644
--- a/tests/cases/compiler/jsFileCompilationBindMultipleDefaultExports.ts
+++ b/tests/cases/compiler/jsFileCompilationBindMultipleDefaultExports.ts
@@ -1,4 +1,5 @@
 // @allowJs: true
+// @checkJs: true
 // @noEmit: true
 // @filename: a.js
 // @target: es6
diff --git a/tests/cases/compiler/jsFileCompilationBindReachabilityErrors.ts b/tests/cases/compiler/jsFileCompilationBindReachabilityErrors.ts
index b95f85c2139..e9273231316 100644
--- a/tests/cases/compiler/jsFileCompilationBindReachabilityErrors.ts
+++ b/tests/cases/compiler/jsFileCompilationBindReachabilityErrors.ts
@@ -1,4 +1,5 @@
 // @allowJs: true
+// @checkJs: true
 // @noEmit: true
 // @filename: a.js
 // @noFallthroughCasesInSwitch: true
diff --git a/tests/cases/compiler/jsFileCompilationBindStrictModeErrors.ts b/tests/cases/compiler/jsFileCompilationBindStrictModeErrors.ts
index 30b43b1990e..527927be6e6 100644
--- a/tests/cases/compiler/jsFileCompilationBindStrictModeErrors.ts
+++ b/tests/cases/compiler/jsFileCompilationBindStrictModeErrors.ts
@@ -1,4 +1,5 @@
 // @allowJs: true
+// @checkJs: true
 // @noEmit: true
 // @filename: a.js
 // @target: es6
diff --git a/tests/cases/compiler/reexportedMissingAlias.ts b/tests/cases/compiler/reexportedMissingAlias.ts
new file mode 100644
index 00000000000..b430cd526c8
--- /dev/null
+++ b/tests/cases/compiler/reexportedMissingAlias.ts
@@ -0,0 +1,9 @@
+// Fixes #15094
+// @Filename: second.d.ts
+export import Component = CompletelyMissing;
+// @Filename: first.d.ts
+import * as Second from './second';
+export = Second;
+// @Filename: crash.ts
+import { Component } from './first';
+class C extends Component { }
diff --git a/tests/cases/compiler/unreachableJavascriptChecked.ts b/tests/cases/compiler/unreachableJavascriptChecked.ts
new file mode 100644
index 00000000000..4db98c4c8c4
--- /dev/null
+++ b/tests/cases/compiler/unreachableJavascriptChecked.ts
@@ -0,0 +1,8 @@
+// @Filename: unreachable.js
+// @allowJs: true
+// @checkJs: true
+// @outDir: out
+function unreachable() {
+    return 1;
+    return 2;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/unreachableJavascriptUnchecked.ts b/tests/cases/compiler/unreachableJavascriptUnchecked.ts
new file mode 100644
index 00000000000..d5b1f45e282
--- /dev/null
+++ b/tests/cases/compiler/unreachableJavascriptUnchecked.ts
@@ -0,0 +1,8 @@
+// @Filename: unreachable.js
+// @allowJs: true
+// @checkJs: false
+// @outDir: out
+function unreachable() {
+    return 1;
+    return 2;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/weakType.ts b/tests/cases/compiler/weakType.ts
new file mode 100644
index 00000000000..f04f36c9c2f
--- /dev/null
+++ b/tests/cases/compiler/weakType.ts
@@ -0,0 +1,56 @@
+interface Settings {
+    timeout?: number;
+    onError?(): void;
+}
+
+function getDefaultSettings() {
+    return { timeout: 1000 };
+}
+
+function doSomething(settings: Settings) { /* ... */ }
+
+// forgot to call `getDefaultSettings`
+// but it is not caught because we don't check for call signatures
+doSomething(getDefaultSettings);
+
+// this is an oddly popular way of defining settings
+// this example is from services/textChanges.ts
+type ConfigurableStart = { useStart?: boolean }
+type ConfigurableEnd = { useEnd?: boolean }
+type ConfigurableStartEnd = ConfigurableStart & ConfigurableEnd
+interface InsertOptions {
+    prefix?: string
+    suffix?: string
+}
+type ChangeOptions = ConfigurableStartEnd & InsertOptions;
+
+function del(options: ConfigurableStartEnd = {},
+             error: { error?: number } = {}) {
+    let changes: ChangeOptions[];
+    changes.push(options);
+    changes.push(error);
+}
+
+class K {
+    constructor(s: string) { }
+}
+// Ctor isn't a weak type because it has a construct signature
+interface Ctor {
+    new (s: string): K
+    n?: number
+}
+let ctor: Ctor = K
+
+type Spoiler = { nope?: string }
+type Weak = {
+    a?: number
+    properties?: {
+        b?: number
+    }
+}
+declare let unknown: {
+    properties: {
+        wrong: string
+    }
+}
+let weak: Weak & Spoiler = unknown
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression1ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression1ESNext.ts
new file mode 100644
index 00000000000..295b6470301
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression1ESNext.ts
@@ -0,0 +1,15 @@
+// @module: esnext
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+})
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression2ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression2ESNext.ts
new file mode 100644
index 00000000000..f0e9b358854
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression2ESNext.ts
@@ -0,0 +1,16 @@
+// @module: esnext
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression3ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression3ESNext.ts
new file mode 100644
index 00000000000..ee7264b8c7e
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression3ESNext.ts
@@ -0,0 +1,14 @@
+// @module: esnext
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts
new file mode 100644
index 00000000000..91342770d7d
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression4ESNext.ts
@@ -0,0 +1,26 @@
+// @module: esnext
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression5ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression5ESNext.ts
new file mode 100644
index 00000000000..173b606a50c
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression5ESNext.ts
@@ -0,0 +1,20 @@
+// @module: esnext
+// @target: esnext
+// @strictNullChecks: true
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare function bar(): boolean;
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpression6ESNext.ts b/tests/cases/conformance/dynamicImport/importCallExpression6ESNext.ts
new file mode 100644
index 00000000000..f09521186e8
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpression6ESNext.ts
@@ -0,0 +1,19 @@
+// @module: esnext
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare function bar(): boolean;
+const specify = bar() ? "./0" : undefined;
+let myModule = import(specify);
+let myModule1 = import(undefined);
+let myModule2 = import(bar() ? "./1" : null);
+let myModule3 = import(null);
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionCheckReturntype1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionCheckReturntype1.ts
new file mode 100644
index 00000000000..1218565fa54
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionCheckReturntype1.ts
@@ -0,0 +1,17 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: true
+
+// @filename: anotherModule.ts
+export class D{}
+
+// @filename: defaultPath.ts
+export class C {}
+
+// @filename: 1.ts
+import * as defaultModule from "./defaultPath";
+import * as anotherModule from "./anotherModule";
+
+let p1: Promise<typeof anotherModule> = import("./defaultPath");
+let p2 = import("./defaultPath") as Promise<typeof anotherModule>;
+let p3: Promise<any> = import("./defaultPath");
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit1.ts
new file mode 100644
index 00000000000..fb299951148
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit1.ts
@@ -0,0 +1,19 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+// @declaration: true
+
+declare function getSpecifier(): string;
+declare var whatToLoad: boolean;
+declare const directory: string;
+declare const moduleFile: number;
+
+import(getSpecifier());
+
+var p0 = import(`${directory}\${moduleFile}`);
+var p1 = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+
+function returnDynamicLoad(path: string) {
+    return import(path);
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit2.ts
new file mode 100644
index 00000000000..4b9196dea20
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit2.ts
@@ -0,0 +1,9 @@
+// @module: esnext
+// @target: esnext
+// @declaration: true
+
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+var p1 = import("./0");
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit3.ts b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit3.ts
new file mode 100644
index 00000000000..6d17d624190
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionDeclarationEmit3.ts
@@ -0,0 +1,15 @@
+// @module: esnext
+// @target: esnext
+// @declaration: true
+
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+declare function getPath(): string;
+import * as Zero from "./0";
+import("./0");
+
+export var p0: Promise<typeof Zero> = import(getPath());
+export var p1: Promise<typeof Zero> = import("./0");
+export var p2: Promise<any> = import("./0");
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionES5AMD.ts b/tests/cases/conformance/dynamicImport/importCallExpressionES5AMD.ts
new file mode 100644
index 00000000000..33c31283ea0
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionES5AMD.ts
@@ -0,0 +1,16 @@
+// @module: amd
+// @target: es5
+// @lib: es6
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionES5CJS.ts b/tests/cases/conformance/dynamicImport/importCallExpressionES5CJS.ts
new file mode 100644
index 00000000000..900ddbdba0c
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionES5CJS.ts
@@ -0,0 +1,16 @@
+// @module: commonjs
+// @target: es5
+// @lib: es6
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionES5System.ts b/tests/cases/conformance/dynamicImport/importCallExpressionES5System.ts
new file mode 100644
index 00000000000..c00ab6899c6
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionES5System.ts
@@ -0,0 +1,16 @@
+// @module: system
+// @target: es5
+// @lib: es6
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionES5UMD.ts b/tests/cases/conformance/dynamicImport/importCallExpressionES5UMD.ts
new file mode 100644
index 00000000000..699b0ffc342
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionES5UMD.ts
@@ -0,0 +1,16 @@
+// @module: umd
+// @target: es5
+// @lib: es6
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionErrorInES2015.ts b/tests/cases/conformance/dynamicImport/importCallExpressionErrorInES2015.ts
new file mode 100644
index 00000000000..a7fcd8533a3
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionErrorInES2015.ts
@@ -0,0 +1,15 @@
+// @module: es2015
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+})
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts b/tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts
new file mode 100644
index 00000000000..38dc47f3207
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionGrammarError.ts
@@ -0,0 +1,14 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+
+declare function getSpecifier(): string;
+declare var whatToLoad: boolean;
+
+var a = ["./0"];
+import(...["PathModule"]);
+
+var p1 = import(...a);
+const p2 = import();
+const p3 = import(,);
+const p4 = import("pathToModule", "secondModule");
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInAMD1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD1.ts
new file mode 100644
index 00000000000..63cfc54c732
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD1.ts
@@ -0,0 +1,15 @@
+// @module: amd
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInAMD2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD2.ts
new file mode 100644
index 00000000000..96b2fd4ceff
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD2.ts
@@ -0,0 +1,17 @@
+// @module: amd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInAMD3.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD3.ts
new file mode 100644
index 00000000000..a2b287b4d95
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD3.ts
@@ -0,0 +1,14 @@
+// @module: amd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInAMD4.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD4.ts
new file mode 100644
index 00000000000..10044ab674c
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInAMD4.ts
@@ -0,0 +1,26 @@
+// @module: amd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInCJS1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS1.ts
new file mode 100644
index 00000000000..e1457017552
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS1.ts
@@ -0,0 +1,15 @@
+// @module: commonjs
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInCJS2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS2.ts
new file mode 100644
index 00000000000..e42a58a290c
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS2.ts
@@ -0,0 +1,19 @@
+// @module: commonjs
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+async function compute(promise: Promise<any>) {
+    let j = await promise;
+    if (!j) {
+        j = await import("./1");
+        return j.backup();
+    }
+    return j.foo();
+}
+
+compute(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInCJS3.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS3.ts
new file mode 100644
index 00000000000..5990eb3a5a2
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS3.ts
@@ -0,0 +1,17 @@
+// @module: commonjs
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInCJS4.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS4.ts
new file mode 100644
index 00000000000..fba246c0b8b
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS4.ts
@@ -0,0 +1,14 @@
+// @module: commonjs
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInCJS5.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS5.ts
new file mode 100644
index 00000000000..db86764802b
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInCJS5.ts
@@ -0,0 +1,26 @@
+// @module: commonjs
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext1.ts
new file mode 100644
index 00000000000..166513321a3
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext1.ts
@@ -0,0 +1,10 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+var p1 = import("./0");
+function arguments() { } // this is allow as the file doesn't have implicit "use strict"
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext2.ts
new file mode 100644
index 00000000000..754f7e865bb
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInScriptContext2.ts
@@ -0,0 +1,11 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+"use strict"
+var p1 = import("./0");
+function arguments() { }
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInSystem1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem1.ts
new file mode 100644
index 00000000000..a69e844c7a7
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem1.ts
@@ -0,0 +1,15 @@
+// @module: system
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInSystem2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem2.ts
new file mode 100644
index 00000000000..c6fac3683ee
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem2.ts
@@ -0,0 +1,17 @@
+// @module: system
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInSystem3.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem3.ts
new file mode 100644
index 00000000000..7f4485d8962
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem3.ts
@@ -0,0 +1,14 @@
+// @module: system
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInSystem4.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem4.ts
new file mode 100644
index 00000000000..1ab3040862c
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInSystem4.ts
@@ -0,0 +1,26 @@
+// @module: system
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInUMD1.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD1.ts
new file mode 100644
index 00000000000..05c4d699104
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD1.ts
@@ -0,0 +1,15 @@
+// @module: umd
+// @target: esnext
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+import("./0");
+var p1 = import("./0");
+p1.then(zero => {
+    return zero.foo();
+});
+
+function foo() {
+    const p2 = import("./0");
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInUMD2.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD2.ts
new file mode 100644
index 00000000000..2f76d0aa267
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD2.ts
@@ -0,0 +1,17 @@
+// @module: umd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+// We use Promise<any> for now as there is no way to specify shape of module object
+function foo(x: Promise<any>) {
+    x.then(value => {
+        let b = new value.B();
+        b.print();
+    })
+}
+
+foo(import("./0"));
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInUMD3.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD3.ts
new file mode 100644
index 00000000000..58d21ee52d0
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD3.ts
@@ -0,0 +1,14 @@
+// @module: umd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+// @filename: 2.ts
+async function foo() {
+    class C extends (await import("./0")).B {}
+    var c = new C();
+    c.print();
+}
+foo();
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionInUMD4.ts b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD4.ts
new file mode 100644
index 00000000000..ef0f0999407
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionInUMD4.ts
@@ -0,0 +1,26 @@
+// @module: umd
+// @target: esnext
+// @filename: 0.ts
+export class B {
+    print() { return "I am B"}
+}
+
+export function foo() { return "foo" }
+
+// @filename: 1.ts
+export function backup() { return "backup"; }
+
+// @filename: 2.ts
+declare var console: any;
+class C {
+    private myModule = import("./0");
+    method() {
+        this.myModule.then(Zero => {
+            console.log(Zero.foo());
+        }, async err => {
+            console.log(err);
+            let one = await import("./1");
+            console.log(one.backup());
+        });
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionReturnPromiseOfAny.ts b/tests/cases/conformance/dynamicImport/importCallExpressionReturnPromiseOfAny.ts
new file mode 100644
index 00000000000..34f0b63be6f
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionReturnPromiseOfAny.ts
@@ -0,0 +1,34 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: true
+// @filename: defaultPath.ts
+export class C {}
+
+// @filename: 1.ts
+import * as defaultModule from "./defaultPath";
+declare function getSpecifier(): string;
+declare function ValidSomeCondition(): boolean;
+declare var whatToLoad: boolean;
+declare const directory: string;
+declare const moduleFile: number;
+
+import(`${directory}\${moduleFile}`);
+import(getSpecifier());
+
+var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
+var p1: Promise<any> = import(getSpecifier());
+var p11: Promise<typeof defaultModule> = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
+p1.then(zero => {
+    return zero.foo();  // ok, zero is any
+});
+
+let j: string;
+var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
+
+function * loadModule(directories: string[]) {
+    for (const directory of directories) {
+        const path = `${directory}\moduleFile`;
+        import(yield path);
+    }
+}
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts b/tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts
new file mode 100644
index 00000000000..3af0ec89ac2
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionSpecifierNotStringTypeError.ts
@@ -0,0 +1,17 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+
+declare function getSpecifier(): boolean;
+declare var whatToLoad: boolean;
+
+// Error specifier is not assignable to string
+import(getSpecifier());
+var p1 = import(getSpecifier());
+const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
+p1.then(zero => {
+    return zero.foo();  // ok, zero is any
+});
+
+var p3 = import(["path1", "path2"]);
+var p4 = import(()=>"PathToModule");
\ No newline at end of file
diff --git a/tests/cases/conformance/dynamicImport/importCallExpressionWithTypeArgument.ts b/tests/cases/conformance/dynamicImport/importCallExpressionWithTypeArgument.ts
new file mode 100644
index 00000000000..895b61af6ff
--- /dev/null
+++ b/tests/cases/conformance/dynamicImport/importCallExpressionWithTypeArgument.ts
@@ -0,0 +1,14 @@
+// @module: commonjs
+// @target: es6
+// @noImplicitAny: false
+
+// @filename: 0.ts
+export function foo() { return "foo"; }
+
+// @filename: 1.ts
+"use strict"
+var p1 = import<Promise<any>>("./0");  // error
+var p2 = import<>("./0");  // error
+// p1.then(value => {
+//     value.anyFunction();
+// })
\ No newline at end of file
diff --git a/tests/cases/conformance/emitter/es2017/forAwait/emitter.forAwait.es2017.ts b/tests/cases/conformance/emitter/es2017/forAwait/emitter.forAwait.es2017.ts
new file mode 100644
index 00000000000..f2d1f46873d
--- /dev/null
+++ b/tests/cases/conformance/emitter/es2017/forAwait/emitter.forAwait.es2017.ts
@@ -0,0 +1,26 @@
+// @target: es2017
+// @lib: esnext
+// @filename: file1.ts
+async function f1() {
+    let y: any;
+    for await (const x of y) {
+    }
+}
+// @filename: file2.ts
+async function f2() {
+    let x: any, y: any;
+    for await (x of y) {
+    }
+}
+// @filename: file3.ts
+async function* f3() {
+    let y: any;
+    for await (const x of y) {
+    }
+}
+// @filename: file4.ts
+async function* f4() {
+    let x: any, y: any;
+    for await (x of y) {
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/jsdoc/checkJsdocParamTag1.ts b/tests/cases/conformance/jsdoc/checkJsdocParamTag1.ts
new file mode 100644
index 00000000000..1586a10472c
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/checkJsdocParamTag1.ts
@@ -0,0 +1,14 @@
+// @allowJS: true
+// @suppressOutputPathCheck: true
+
+// @filename: 0.js
+// @ts-check
+/**
+ * @param {number=} n
+ * @param {string} [s]
+ */
+function foo(n, s) {}
+
+foo();
+foo(1);
+foo(1, "hi");
\ No newline at end of file
diff --git a/tests/cases/conformance/jsdoc/checkJsdocReturnTag1.ts b/tests/cases/conformance/jsdoc/checkJsdocReturnTag1.ts
new file mode 100644
index 00000000000..fde7c3fa0f4
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/checkJsdocReturnTag1.ts
@@ -0,0 +1,25 @@
+// @allowJs: true
+// @out: dummy.js
+
+// @filename: returns.js
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return "hello";
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return "hello world";
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/jsdoc/checkJsdocReturnTag2.ts b/tests/cases/conformance/jsdoc/checkJsdocReturnTag2.ts
new file mode 100644
index 00000000000..02b7fbeacef
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/checkJsdocReturnTag2.ts
@@ -0,0 +1,18 @@
+// @allowJs: true
+// @out: dummy.js
+
+// @filename: returns.js
+// @ts-check
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+
+/**
+ * @returns {string | number} This comment is not currently exposed
+ */
+function f1() {
+    return 5 || true;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/salsa/jsDocTypes2.ts b/tests/cases/conformance/jsdoc/checkJsdocTypeTag1.ts
similarity index 76%
rename from tests/cases/conformance/salsa/jsDocTypes2.ts
rename to tests/cases/conformance/jsdoc/checkJsdocTypeTag1.ts
index 21107f87ccf..fbed9d83b22 100644
--- a/tests/cases/conformance/salsa/jsDocTypes2.ts
+++ b/tests/cases/conformance/jsdoc/checkJsdocTypeTag1.ts
@@ -3,8 +3,15 @@
 
 // @filename: 0.js
 // @ts-check
+/** @type {String} */
+var S = "hello world";
+
+/** @type {number} */
+var n = 10;
+
 /** @type {*} */
 var anyT = 2;
+anyT = "hello";
 
 /** @type {?} */
 var anyT1 = 2;
diff --git a/tests/cases/conformance/salsa/jsDocTypes3.ts b/tests/cases/conformance/jsdoc/checkJsdocTypeTag2.ts
similarity index 57%
rename from tests/cases/conformance/salsa/jsDocTypes3.ts
rename to tests/cases/conformance/jsdoc/checkJsdocTypeTag2.ts
index bf207bca869..a7dffdb90a7 100644
--- a/tests/cases/conformance/salsa/jsDocTypes3.ts
+++ b/tests/cases/conformance/jsdoc/checkJsdocTypeTag2.ts
@@ -3,6 +3,11 @@
 
 // @filename: 0.js
 // @ts-check
+/** @type {String} */
+var S = true;
+
+/** @type {number} */
+var n = "hello";
 
 /** @type {function (number)} */
 const x1 = (a) => a + 1;
@@ -13,4 +18,8 @@ const x2 = (a) => a + 1;
 
 /** @type {string} */
 var a;
-a = x2(0);
\ No newline at end of file
+a = x2(0);
+
+/** @type {function (number): number} */
+const x2 = (a) => a.concat("hi");
+x2(0);
\ No newline at end of file
diff --git a/tests/cases/conformance/jsdoc/jsdocReturnTag1.ts b/tests/cases/conformance/jsdoc/jsdocReturnTag1.ts
new file mode 100644
index 00000000000..a425322a749
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/jsdocReturnTag1.ts
@@ -0,0 +1,23 @@
+// @allowJs: true
+// @filename: returns.js
+// @out: dummy.js
+/**
+ * @returns {string} This comment is not currently exposed
+ */
+function f() {
+    return 5;
+}
+
+/**
+ * @returns {string=} This comment is not currently exposed
+ */
+function f1() {
+    return 5;
+}
+
+/**
+ * @returns {string|number} This comment is not currently exposed
+ */
+function f2() {
+    return 5 || "hello";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/salsa/jsDocTypes.ts b/tests/cases/conformance/jsdoc/jsdocTypeTag.ts
similarity index 87%
rename from tests/cases/conformance/salsa/jsDocTypes.ts
rename to tests/cases/conformance/jsdoc/jsdocTypeTag.ts
index 9a13c533d0a..d566c61e185 100644
--- a/tests/cases/conformance/salsa/jsDocTypes.ts
+++ b/tests/cases/conformance/jsdoc/jsdocTypeTag.ts
@@ -57,7 +57,8 @@ var nullable;
 /** @type {Object} */
 var Obj;
 
-
+/** @type {Function} */
+var Func;
 
 // @filename: b.ts
 var S: string;
@@ -78,3 +79,4 @@ var P: Promise<any>;
 var p: Promise<any>;
 var nullable: number | null;
 var Obj: any;
+var Func: Function;
diff --git a/tests/cases/conformance/jsdoc/returns.ts b/tests/cases/conformance/jsdoc/returns.ts
deleted file mode 100644
index 72cb4a6cb67..00000000000
--- a/tests/cases/conformance/jsdoc/returns.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// @allowJs: true
-// @filename: returns.js
-// @out: dummy.js
-/**
- * @returns {string} This comment is not currently exposed
- */
-function f() {
-    return "";
-}
diff --git a/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx b/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx
index a9466a43983..32a1af66f84 100644
--- a/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx
+++ b/tests/cases/conformance/jsx/tsxGenericAttributesType9.tsx
@@ -5,7 +5,7 @@
 
 import React = require('react');
 
-export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P> {
+export function makeP<P>(Ctor: React.ComponentClass<P>) {
 	return class extends React.PureComponent<P, void> {
 		public render(): JSX.Element {
 			return (
@@ -13,4 +13,5 @@ export function makeP<P>(Ctor: React.ComponentClass<P>): React.ComponentClass<P>
 			);
 		}
 	};
-}
\ No newline at end of file
+}
+
diff --git a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx
index d8897321f0b..525d035cbfe 100644
--- a/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx
+++ b/tests/cases/conformance/jsx/tsxStatelessFunctionComponentOverload1.tsx
@@ -38,10 +38,10 @@ declare function TestingOptional(a: {y1: boolean, y2?: number, y3: boolean}): JS
 
 // OK
 const e1 = <TestingOptional />
-const e2 = <TestingOptional extra-prop/>
 const e3 = <TestingOptional y1="hello"/>
 const e4 = <TestingOptional y1="hello" y2={1000} />
 const e5 = <TestingOptional y1 y3/>
 const e6 = <TestingOptional y1 y3 y2={10} />
+const e2 = <TestingOptional y1 y3 extra-prop/>
 
 
diff --git a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
index a9d5872705c..55c1acb03b3 100644
--- a/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
+++ b/tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts
@@ -1,5 +1,9 @@
 // @declaration: true
 var a: object & string = ""; // error
 var b: object | string = ""; // ok
+var c: object & {} = 123; // error
 a = b; // error
 b = a; // ok
+
+const foo: object & {} = {bar: 'bar'}; // ok
+const bar: object & {err: string} = {bar: 'bar'}; // error
diff --git a/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts b/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts
index 11b32abdf50..1f193285681 100644
--- a/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts
+++ b/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts
@@ -29,20 +29,20 @@ module TargetHasOptional {
     var e: E;
     var f: F;
 
-    // all ok
+    // disallowed by weak type checking
     c = d;
     c = e;
     c = f;
-    c = a;
-
     a = d;
     a = e;
     a = f;
-    a = c;
-
     b = d;
     b = e;
     b = f;
+
+    // ok
+    c = a;
+    a = c;
     b = a;
     b = c;
 }
@@ -86,4 +86,4 @@ module SourceHasOptional {
     b = f; // error
     b = a; // ok
     b = c; // ok
-}
\ No newline at end of file
+}
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts
index 9a83bb660f8..1095a2183f3 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembers5.ts
@@ -41,7 +41,7 @@ module Optional {
     }
 
     class B implements A {
-        fooo: Derived; // ok
+        fooo: Derived; // weak type error
     }
 
     interface A2 {
@@ -49,7 +49,7 @@ module Optional {
     }
 
     class B2 implements A2 {
-        2: Derived; // ok
+        2: Derived; // weak type error
     }
 
     interface A3 {
@@ -57,6 +57,6 @@ module Optional {
     }
 
     class B3 implements A3 {
-        '1.0': Derived; // ok
+        '1.0': Derived; // weak type error
     }
-}
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/codeFixAddMissingMember5.ts b/tests/cases/fourslash/codeFixAddMissingMember5.ts
index cbabc0ba6c5..db893cb61d3 100644
--- a/tests/cases/fourslash/codeFixAddMissingMember5.ts
+++ b/tests/cases/fourslash/codeFixAddMissingMember5.ts
@@ -11,9 +11,11 @@
 ////}
 ////|]
 
-verify.rangeAfterCodeFix(`class C {
+verify.getAndApplyCodeFix(/*errorCode*/ undefined, /*index*/ 0);
+verify.currentFileContentIs(`class C {
     static method() {
         ()=>{ this.foo === 10 };
     }
 }
-C.foo = undefined;`, /*includeWhiteSpace*/false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
+C.foo = undefined;
+`);
\ No newline at end of file
diff --git a/tests/cases/fourslash/codeFixAddMissingMember7.ts b/tests/cases/fourslash/codeFixAddMissingMember7.ts
index 0e937a3ab6e..8ac7f2b5aff 100644
--- a/tests/cases/fourslash/codeFixAddMissingMember7.ts
+++ b/tests/cases/fourslash/codeFixAddMissingMember7.ts
@@ -9,7 +9,9 @@
 ////}
 ////|]
 
-verify.rangeAfterCodeFix(`class C {
+verify.getAndApplyCodeFix(/*errorCode*/ undefined, /*index*/ 2)
+verify.currentFileContentIs(`class C {
     static p = ()=>{ this.foo === 10 };
 }
-C.foo = undefined;`, /*includeWhiteSpace*/false, /*errorCode*/ undefined, /*index*/ 2);
\ No newline at end of file
+C.foo = undefined;
+`);
diff --git a/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts
new file mode 100644
index 00000000000..435b78ba3fa
--- /dev/null
+++ b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles1.ts
@@ -0,0 +1,34 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+
+// @Filename: f2.js
+//// import * as X from "./f1";
+//// X.C.m0(1, "", []);
+//// X.C.x;
+//// let c = new X.C;
+//// c.m1();
+//// c.y = {};
+
+// @Filename: f1.ts
+//// export class C {[|
+////     |]x: number;
+////     static y: string;
+//// }
+
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+
+verify.rangeIs(`
+    y: { [x: string]: any; };
+    m1(): any {
+        throw new Error("Method not implemented.");
+    }
+    static x: any;
+    static m0(arg0: any, arg1: any, arg2: any): any {
+        throw new Error("Method not implemented.");
+    }
+`);
\ No newline at end of file
diff --git a/tests/cases/fourslash/codeFixUndeclaredAcrossFiles2.ts b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles2.ts
new file mode 100644
index 00000000000..04e2afc667c
--- /dev/null
+++ b/tests/cases/fourslash/codeFixUndeclaredAcrossFiles2.ts
@@ -0,0 +1,39 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+
+// @Filename: f2.ts
+//// import * as X from "./f1";
+//// X.C.m0(1, "", []);
+//// X.C.x;
+//// let c = new X.C;
+//// c.m1();
+//// c.y = {};
+
+// @Filename: f1.js
+//// [|export class C {
+////     constructor() { }
+//// }
+////
+//// |]
+
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+
+verify.rangeIs(`
+export class C {
+    m1() {
+        throw new Error("Method not implemented.");
+    }
+    static m0(arg0, arg1, arg2) {
+        throw new Error("Method not implemented.");
+    }
+    constructor() {
+        this.y = undefined;
+    }
+}
+C.x = undefined;
+`);
\ No newline at end of file
diff --git a/tests/cases/fourslash/codeFixUndeclaredInStaticMethod.ts b/tests/cases/fourslash/codeFixUndeclaredInStaticMethod.ts
new file mode 100644
index 00000000000..75be5420e43
--- /dev/null
+++ b/tests/cases/fourslash/codeFixUndeclaredInStaticMethod.ts
@@ -0,0 +1,26 @@
+/// <reference path='fourslash.ts' />
+
+//// class A {[|
+////     |]static foo0() {
+////         this.m1(1,2,3);
+////         A.m2(1,2);
+////         this.prop1 = 10;
+////         A.prop2 = "asdf";
+////     }
+//// }
+
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+
+verify.rangeIs(`
+    static prop2: string;
+    static prop1: number;
+    static m2(arg0: any, arg1: any): any {
+        throw new Error("Method not implemented.");
+    }
+    static m1(arg0: any, arg1: any, arg2: any): any {
+        throw new Error("Method not implemented.");
+    }
+`);
diff --git a/tests/cases/fourslash/codeFixUndeclaredMethod.ts b/tests/cases/fourslash/codeFixUndeclaredMethod.ts
new file mode 100644
index 00000000000..6a61f8421aa
--- /dev/null
+++ b/tests/cases/fourslash/codeFixUndeclaredMethod.ts
@@ -0,0 +1,27 @@
+/// <reference path='fourslash.ts' />
+
+//// class A {[|
+////     |]constructor() {
+////         this.foo1(1,2,3);
+////         // 7 type args
+////         this.foo2<1,2,3,4,5,6,7>();
+////         // 8 type args
+////         this.foo3<1,2,3,4,5,6,7,8>();
+////     }
+//// }
+
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+verify.getAndApplyCodeFix(/*errorCode*/undefined, 0);
+
+verify.rangeIs(`
+    foo3<T0, T1, T2, T3, T4, T5, T6, T7>(): any {
+        throw new Error("Method not implemented.");
+    }
+    foo2<T, U, V, W, X, Y, Z>(): any {
+        throw new Error("Method not implemented.");
+    }
+    foo1(arg0: any, arg1: any, arg2: any): any {
+        throw new Error("Method not implemented.");
+    }
+`);
\ No newline at end of file
diff --git a/tests/cases/fourslash/codeFixUndeclaredPropertyAccesses.ts b/tests/cases/fourslash/codeFixUndeclaredPropertyAccesses.ts
new file mode 100644
index 00000000000..ee05d2c0a9c
--- /dev/null
+++ b/tests/cases/fourslash/codeFixUndeclaredPropertyAccesses.ts
@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts' />
+
+//// interface I { x: number; }
+//// let i: I;
+//// i.y;
+//// i.foo();
+//// enum E { a,b }
+//// let e: typeof E;
+//// e.a;
+//// e.c;
+//// let obj = { a: 1, b: "asdf"};
+//// obj.c;
+//// type T<U> = I | U;
+//// let t: T<number>;
+//// t.x;
+
+verify.not.codeFixAvailable();
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionEntryForUnionMethod.ts b/tests/cases/fourslash/completionEntryForUnionMethod.ts
index 8c112a6d52e..f8fd9ad9dc9 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: 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.");
+    "(property) map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])",
+    "Calls 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: 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}");
+verify.completionListContains('map', "(property) map: (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])");
\ No newline at end of file
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index 3fada673f35..3e80b005625 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -236,7 +236,9 @@ declare namespace FourSlashInterface {
         noMatchingBracePositionInCurrentFile(bracePosition: number): void;
         DocCommentTemplate(expectedText: string, expectedOffset: number, empty?: boolean): void;
         noDocCommentTemplate(): void;
-        rangeAfterCodeFix(expectedText: string, includeWhiteSpace?: boolean, errorCode?: number, index?: number): void;
+        rangeAfterCodeFix(expectedText: string, includeWhiteSpace?: boolean, errorCode?: number, index?: number): void
+        getAndApplyCodeFix(errorCode?: number, index?: number): void;
+        rangeIs(expectedText: string, includeWhiteSpace?: boolean): void;
         fileAfterApplyingRefactorAtMarker(markerName: string, expectedContent: string, refactorNameToApply: string, formattingOptions?: FormatCodeOptions): void;
         importFixAtPosition(expectedTextArray: string[], errorCode?: number): void;
 
diff --git a/tests/cases/fourslash/importNameCodeFixUMDGlobalReact0.ts b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact0.ts
new file mode 100644
index 00000000000..260c34d10a6
--- /dev/null
+++ b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact0.ts
@@ -0,0 +1,28 @@
+/// <reference path="fourslash.ts" />
+
+// @jsx: react
+
+// @Filename: /node_modules/@types/react/index.d.ts
+////export = React;
+////export as namespace React;
+////declare namespace React {
+////    export class Component { render(): JSX.Element | null; }
+////}
+////declare global {
+////    namespace JSX {
+////        interface Element {}
+////    }
+////}
+
+// @Filename: /a.tsx
+////[|import { Component } from "react";
+////export class MyMap extends Component { }
+////<MyMap/>;|]
+
+goTo.file("/a.tsx");
+
+verify.importFixAtPosition([
+`import { Component } from "react";
+import * as React from "react";
+export class MyMap extends Component { }
+<MyMap/>;`]);
diff --git a/tests/cases/fourslash/importNameCodeFixUMDGlobalReact1.ts b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact1.ts
new file mode 100644
index 00000000000..ccd69c50199
--- /dev/null
+++ b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact1.ts
@@ -0,0 +1,28 @@
+/// <reference path="fourslash.ts" />
+
+// @jsx: react
+
+// @Filename: /node_modules/@types/react/index.d.ts
+////export = React;
+////export as namespace React;
+////declare namespace React {
+////    export class Component { render(): JSX.Element | null; }
+////}
+////declare global {
+////    namespace JSX {
+////        interface Element {}
+////    }
+////}
+
+// @Filename: /a.tsx
+////[|import { Component } from "react";
+////export class MyMap extends Component { }
+////<MyMap></MyMap>;|]
+
+goTo.file("/a.tsx");
+
+verify.importFixAtPosition([
+`import { Component } from "react";
+import * as React from "react";
+export class MyMap extends Component { }
+<MyMap></MyMap>;`]);
diff --git a/tests/cases/fourslash/importNameCodeFixUMDGlobalReact2.ts b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact2.ts
new file mode 100644
index 00000000000..a3c8253fbd1
--- /dev/null
+++ b/tests/cases/fourslash/importNameCodeFixUMDGlobalReact2.ts
@@ -0,0 +1,21 @@
+/// <reference path="fourslash.ts" />
+
+// https://github.com/Microsoft/TypeScript/issues/16065
+
+// @jsx: react
+// @jsxFactory: factory
+
+// @Filename: /factory.ts
+////export function factory() { return {}; }
+////declare global {
+////    namespace JSX {
+////        interface Element {}
+////    }
+////}
+
+// @Filename: /a.tsx
+////[|<div/>|]
+
+goTo.file("/a.tsx");
+verify.not
+verify.importFixAtPosition([]);
diff --git a/tests/cases/fourslash/jsxQualifiedTagCompletion.ts b/tests/cases/fourslash/jsxQualifiedTagCompletion.ts
new file mode 100644
index 00000000000..3d799324e7e
--- /dev/null
+++ b/tests/cases/fourslash/jsxQualifiedTagCompletion.ts
@@ -0,0 +1,15 @@
+/// <reference path="fourslash.ts" />
+
+//@Filename: file.tsx
+//// declare var React: any;
+//// namespace NS {
+////     export var Foo: any = null;
+//// }
+//// const j = <NS.Foo>Hello!/**/
+//// 
+
+goTo.marker();
+edit.insert("</");
+verify.completionListContains("NS.Foo");
+verify.not.completionListContains("Foo");
+verify.completionListCount(1);
diff --git a/tests/lib/react.d.ts b/tests/lib/react.d.ts
index 7f03899eb6c..aead9f9f23c 100644
--- a/tests/lib/react.d.ts
+++ b/tests/lib/react.d.ts
@@ -159,7 +159,8 @@ declare namespace __React {
     type ReactInstance = Component<any, any> | Element;
 
     // Base component for plain JS classes
-    class Component<P, S> implements ComponentLifecycle<P, S> {
+    interface Component<P, S> extends ComponentLifecycle<P, S> { }
+    class Component<P, S> {
         constructor(props?: P, context?: any);
         setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
         setState(state: S, callback?: () => any): void;
diff --git a/tests/webTestResults.html b/tests/webTestResults.html
index 9c403248f94..f747cdfa75c 100644
--- a/tests/webTestResults.html
+++ b/tests/webTestResults.html
@@ -1,21 +1,26 @@
-<html>
+<!DOCTYPE html>
+<html>
 <head>
   <meta charset="utf-8">
   <title>Mocha Tests</title>
   <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
   <link rel="icon" href="./webhost/favicon-32x32.png"/>
+  <style>
+.btn {
+  color: #ffffff;
+  background: #3498db;
+  border-radius: 30px;
+  font-size: 50px;
+}
+.btn:hover { background: #50c7ff; }
+.btn:focus { background: #50c7ff; }
+  </style>
 </head>
 <body>
   <div id='setup'>
-    <div>
-      <button id='selectCompilerBtn' onclick='location.href="http://localhost:8888/tests/webTestResults.html?grep=compiler"'>Select Compiler Tests</button>
-      <button id='selectFourslashBtn' onclick='location.href="http://localhost:8888/tests/webTestResults.html?grep=fourslash"'>Select Fourslash Tests</button>
-    </div>
-    <button id='runTestBtn' onclick='runTests()'>Run Tests</button>
+    <button id='runTestBtn' onclick='runTests()' type="button" class="btn">Run Tests</button>
   </div>
-
   <div id="mocha"></div>
-  <script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-2.1.0.js"></script>
   <script src="../node_modules/mocha/mocha.js"></script>
   <script>mocha.setup('bdd')</script>
   <script src="../built/local/bundle.js"></script>
diff --git a/tslint.json b/tslint.json
index 9552d193a70..d3178915fe4 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1,7 +1,7 @@
 {
     "rulesDirectory": "built/local/tslint",
     "rules": {
-        "no-bom": true,
+        "boolean-trivia": true,
         "class-name": true,
         "comment-format": [true,
             "check-space"
@@ -9,25 +9,35 @@
         "indent": [true,
             "spaces"
         ],
+        "jsdoc-format": true,
         "linebreak-style": [true, "CRLF"],
+        "next-line": [true,
+            "check-catch",
+            "check-else"
+        ],
+        "no-bom": true,
+        "no-in-operator": true,
+        "no-increment-decrement": true,
+        "no-inferrable-types": true,
+        "no-internal-module": true,
+        "no-null-keyword": true,
+        "no-switch-case-fall-through": true,
+        "no-trailing-whitespace": [true, "ignore-template-strings"],
+        "no-type-assertion-whitespace": true,
+        "no-var-keyword": true,
+        "object-literal-surrounding-space": true,
         "one-line": [true,
             "check-open-brace",
             "check-whitespace"
         ],
-        "no-var-keyword": true,
+        "prefer-const": true,
         "quotemark": [true,
             "double",
             "avoid-escape"
         ],
         "semicolon": [true, "always", "ignore-bound-class-methods"],
-        "whitespace": [true,
-            "check-branch",
-            "check-decl",
-            "check-operator",
-            "check-module",
-            "check-separator",
-            "check-type"
-        ],
+        "triple-equals": true,
+        "type-operator-spacing": true,
         "typedef-whitespace": [
             true,
             {
@@ -45,23 +55,13 @@
                 "variable-declaration": "onespace"
             }
         ],
-        "next-line": [true,
-            "check-catch",
-            "check-else"
-        ],
-        "no-internal-module": true,
-        "no-trailing-whitespace": [true, "ignore-template-strings"],
-        "no-inferrable-types": true,
-        "no-null-keyword": true,
-        "boolean-trivia": true,
-        "type-operator-spacing": true,
-        "prefer-const": true,
-        "no-increment-decrement": true,
-        "object-literal-surrounding-space": true,
-        "no-type-assertion-whitespace": true,
-        "no-in-operator": true,
-        "no-switch-case-fall-through": true,
-        "triple-equals": true,
-        "jsdoc-format": true
-    }
+        "whitespace": [true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-module",
+            "check-separator",
+            "check-type"
+        ]	
+	}
 }