Merge branch 'master' into fix15959

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
     });
 

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;

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;
     }

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 }`. */

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}},`);

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 = [];

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

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;
 

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;

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:

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;
 

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];
     }
 

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:

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);

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
                             )

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";`
+    };
 }

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);
         }
 
         /**

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

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 {

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);
         }

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:

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)(

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,
 

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
                     }]

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;

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() {

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: ""

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) {

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": {

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) {

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()
+                };
+            }
+        }
     }
 }

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));

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;
                         }
                     }
 

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:

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: [] };
         }

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;
         }
     }

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);

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);
         }
     }
 }

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);

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))

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

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;

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))
 

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

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))

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

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))
 

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

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))

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; }

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[]'.
     

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
-    }
+    }
+    

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 = {}));

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))

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

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;
+}());

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))
+

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
+

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");

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))
+

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"
+

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";
+}

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";
+}

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"
+}

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;
+}

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;
+}

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
+}

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";

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))
+

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

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);

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);

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)} */

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))

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))
 	}
 }
 

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>

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

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

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))
 

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) {

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) {

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))

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

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))

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

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 }

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 }

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))
 

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 () { });
 

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
 

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[][]

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[][]

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))
 

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

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))

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
 

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;

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";