Merge branch 'master' into configFileDiag

src/compiler/binder.ts

@@ -230,6 +230,10 @@ namespace ts {
         // Should not be called on a declaration with a computed property name,
         // unless it is a well known Symbol.
         function getDeclarationName(node: Declaration): __String {
+            if (node.kind === SyntaxKind.ExportAssignment) {
+                return (<ExportAssignment>node).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;
+            }
+
             const name = getNameOfDeclaration(node);
             if (name) {
                 if (isAmbientModule(node)) {
@@ -261,8 +265,6 @@ namespace ts {
                     return InternalSymbolName.Index;
                 case SyntaxKind.ExportDeclaration:
                     return InternalSymbolName.ExportStar;
-                case SyntaxKind.ExportAssignment:
-                    return (<ExportAssignment>node).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;
                 case SyntaxKind.BinaryExpression:
                     if (getSpecialPropertyAssignmentKind(node as BinaryExpression) === SpecialPropertyAssignmentKind.ModuleExports) {
                         // module.exports = ...
@@ -2144,7 +2146,7 @@ namespace ts {
                     // falls through
                 case SyntaxKind.JSDocPropertyTag:
                     const propTag = node as JSDocPropertyLikeTag;
-                    const flags = propTag.isBracketed || propTag.typeExpression.type.kind === SyntaxKind.JSDocOptionalType ?
+                    const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === SyntaxKind.JSDocOptionalType ?
                         SymbolFlags.Property | SymbolFlags.Optional :
                         SymbolFlags.Property;
                     return declareSymbolAndAddToSymbolTable(propTag, flags, SymbolFlags.PropertyExcludes);
@@ -2269,16 +2271,13 @@ namespace ts {
         function isExportsOrModuleExportsOrAlias(node: Node): boolean {
             return isExportsIdentifier(node) ||
                 isModuleExportsPropertyAccessExpression(node) ||
-                isNameOfExportsOrModuleExportsAliasDeclaration(node);
+                isIdentifier(node) && isNameOfExportsOrModuleExportsAliasDeclaration(node);
         }
 
-        function isNameOfExportsOrModuleExportsAliasDeclaration(node: Node) {
-            if (isIdentifier(node)) {
-                const symbol = lookupSymbolForName(node.escapedText);
-                return symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) &&
-                    symbol.valueDeclaration.initializer && isExportsOrModuleExportsOrAliasOrAssignment(symbol.valueDeclaration.initializer);
-            }
-            return false;
+        function isNameOfExportsOrModuleExportsAliasDeclaration(node: Identifier): boolean {
+            const symbol = lookupSymbolForName(node.escapedText);
+            return symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) &&
+                symbol.valueDeclaration.initializer && isExportsOrModuleExportsOrAliasOrAssignment(symbol.valueDeclaration.initializer);
         }
 
         function isExportsOrModuleExportsOrAliasOrAssignment(node: Node): boolean {
@@ -2352,20 +2351,22 @@ namespace ts {
             // Look up the function in the local scope, since prototype assignments should
             // follow the function declaration
             const leftSideOfAssignment = node.left as PropertyAccessExpression;
-            const target = leftSideOfAssignment.expression as Identifier;
+            const target = leftSideOfAssignment.expression;
 
-            // Fix up parent pointers since we're going to use these nodes before we bind into them
-            leftSideOfAssignment.parent = node;
-            target.parent = leftSideOfAssignment;
+            if (isIdentifier(target)) {
+                // Fix up parent pointers since we're going to use these nodes before we bind into them
+                leftSideOfAssignment.parent = node;
+                target.parent = leftSideOfAssignment;
 
-            if (isNameOfExportsOrModuleExportsAliasDeclaration(target)) {
-                // This can be an alias for the 'exports' or 'module.exports' names, e.g.
-                //    var util = module.exports;
-                //    util.property = function ...
-                bindExportsPropertyAssignment(node);
-            }
-            else {
-                bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false);
+                if (isNameOfExportsOrModuleExportsAliasDeclaration(target)) {
+                    // This can be an alias for the 'exports' or 'module.exports' names, e.g.
+                    //    var util = module.exports;
+                    //    util.property = function ...
+                    bindExportsPropertyAssignment(node);
+                }
+                else {
+                    bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false);
+                }
             }
         }
 
@@ -2697,6 +2698,12 @@ namespace ts {
 
         if (expression.kind === SyntaxKind.ImportKeyword) {
             transformFlags |= TransformFlags.ContainsDynamicImport;
+
+            // A dynamic 'import()' call that contains a lexical 'this' will
+            // require a captured 'this' when emitting down-level.
+            if (subtreeFlags & TransformFlags.ContainsLexicalThis) {
+                transformFlags |= TransformFlags.ContainsCapturedLexicalThis;
+            }
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;

src/compiler/checker.ts

@@ -503,6 +503,12 @@ namespace ts {
             Inferential = 2,           // Inferential typing
         }
 
+        const enum CallbackCheck {
+            None,
+            Bivariant,
+            Strict,
+        }
+
         const builtinGlobals = createSymbolTable();
         builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
 
@@ -902,6 +908,7 @@ namespace ts {
             const originalLocation = location; // needed for did-you-mean error reporting, which gathers candidates starting from the original location
             let result: Symbol;
             let lastLocation: Node;
+            let lastNonBlockLocation: Node;
             let propertyWithInvalidInitializer: Node;
             const errorLocation = location;
             let grandparent: Node;
@@ -1120,6 +1127,9 @@ namespace ts {
                         }
                         break;
                 }
+                if (location.kind !== SyntaxKind.Block) {
+                    lastNonBlockLocation = location;
+                }
                 lastLocation = location;
                 location = location.parent;
             }
@@ -1127,7 +1137,7 @@ namespace ts {
             // We just climbed up parents looking for the name, meaning that we started in a descendant node of `lastLocation`.
             // If `result === lastLocation.symbol`, that means that we are somewhere inside `lastLocation` looking up a name, and resolving to `lastLocation` itself.
             // That means that this is a self-reference of `lastLocation`, and shouldn't count this when considering whether `lastLocation` is used.
-            if (isUse && result && nameNotFoundMessage && noUnusedIdentifiers && result !== lastLocation.symbol) {
+            if (isUse && result && nameNotFoundMessage && noUnusedIdentifiers && result !== lastNonBlockLocation.symbol) {
                 result.isReferenced = true;
             }
 
@@ -8510,7 +8520,7 @@ namespace ts {
         function isSignatureAssignableTo(source: Signature,
             target: Signature,
             ignoreReturnTypes: boolean): boolean {
-            return compareSignaturesRelated(source, target, /*checkAsCallback*/ false, ignoreReturnTypes, /*reportErrors*/ false,
+            return compareSignaturesRelated(source, target, CallbackCheck.None, ignoreReturnTypes, /*reportErrors*/ false,
                 /*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;
         }
 
@@ -8521,7 +8531,7 @@ namespace ts {
          */
         function compareSignaturesRelated(source: Signature,
             target: Signature,
-            checkAsCallback: boolean,
+            callbackCheck: CallbackCheck,
             ignoreReturnTypes: boolean,
             reportErrors: boolean,
             errorReporter: ErrorReporter,
@@ -8540,7 +8550,7 @@ namespace ts {
             }
 
             const kind = target.declaration ? target.declaration.kind : SyntaxKind.Unknown;
-            const strictVariance = strictFunctionTypes && kind !== SyntaxKind.MethodDeclaration &&
+            const strictVariance = !callbackCheck && strictFunctionTypes && kind !== SyntaxKind.MethodDeclaration &&
                 kind !== SyntaxKind.MethodSignature && kind !== SyntaxKind.Constructor;
             let result = Ternary.True;
 
@@ -8582,8 +8592,8 @@ namespace ts {
                 const callbacks = sourceSig && targetSig && !sourceSig.typePredicate && !targetSig.typePredicate &&
                     (getFalsyFlags(sourceType) & TypeFlags.Nullable) === (getFalsyFlags(targetType) & TypeFlags.Nullable);
                 const related = callbacks ?
-                    compareSignaturesRelated(targetSig, sourceSig, /*checkAsCallback*/ true, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :
-                    !checkAsCallback && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
+                    compareSignaturesRelated(targetSig, sourceSig, strictVariance ? CallbackCheck.Strict : CallbackCheck.Bivariant, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :
+                    !callbackCheck && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
                 if (!related) {
                     if (reportErrors) {
                         errorReporter(Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
@@ -8618,7 +8628,7 @@ namespace ts {
                     // When relating callback signatures, we still need to relate return types bi-variantly as otherwise
                     // the containing type wouldn't be co-variant. For example, interface Foo<T> { add(cb: () => T): void }
                     // wouldn't be co-variant for T without this rule.
-                    result &= checkAsCallback && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) ||
+                    result &= callbackCheck === CallbackCheck.Bivariant && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) ||
                         compareTypes(sourceReturnType, targetReturnType, reportErrors);
                 }
 
@@ -9062,6 +9072,13 @@ namespace ts {
                         (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) {
                         return false;
                     }
+                    if (target.flags & TypeFlags.Union) {
+                        const discriminantType = findMatchingDiscriminantType(source, target as UnionType);
+                        if (discriminantType)  {
+                            // check excess properties against discriminant type only, not the entire union
+                            return hasExcessProperties(source, discriminantType, reportErrors);
+                        }
+                    }
                     for (const prop of getPropertiesOfObjectType(source)) {
                         if (!isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -9138,20 +9155,24 @@ namespace ts {
             }
 
             function findMatchingDiscriminantType(source: Type, target: UnionOrIntersectionType) {
+                let match: Type;
                 const sourceProperties = getPropertiesOfObjectType(source);
                 if (sourceProperties) {
-                    for (const sourceProperty of sourceProperties) {
-                        if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
-                            const sourceType = getTypeOfSymbol(sourceProperty);
-                            for (const type of target.types) {
-                                const targetType = getTypeOfPropertyOfType(type, sourceProperty.escapedName);
-                                if (targetType && isRelatedTo(sourceType, targetType)) {
-                                    return type;
+                    const sourceProperty = findSingleDiscriminantProperty(sourceProperties, target);
+                    if (sourceProperty) {
+                        const sourceType = getTypeOfSymbol(sourceProperty);
+                        for (const type of target.types) {
+                            const targetType = getTypeOfPropertyOfType(type, sourceProperty.escapedName);
+                            if (targetType && isRelatedTo(sourceType, targetType)) {
+                                if (match) {
+                                    return undefined;
                                 }
+                                match = type;
                             }
                         }
                     }
                 }
+                return match;
             }
 
             function typeRelatedToEachType(source: Type, target: IntersectionType, reportErrors: boolean): Ternary {
@@ -9715,7 +9736,7 @@ namespace ts {
              */
             function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean): Ternary {
                 return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target,
-                    /*checkAsCallback*/ false, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
+                    CallbackCheck.None, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);
             }
 
             function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {
@@ -11154,6 +11175,19 @@ namespace ts {
             return false;
         }
 
+        function findSingleDiscriminantProperty(sourceProperties: Symbol[], target: Type): Symbol | undefined {
+            let result: Symbol;
+            for (const sourceProperty of sourceProperties) {
+                if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
+                    if (result) {
+                        return undefined;
+                    }
+                    result = sourceProperty;
+                }
+            }
+            return result;
+        }
+
         function isOrContainsMatchingReference(source: Node, target: Node) {
             return isMatchingReference(source, target) || containsMatchingReference(source, target);
         }
@@ -14796,11 +14830,7 @@ namespace ts {
                 //   where this references the constructor function object of a derived class,
                 //   a super property access is permitted and must specify a public static member function of the base class.
                 if (languageVersion < ScriptTarget.ES2015) {
-                    const hasNonMethodDeclaration = forEachProperty(prop, p => {
-                        const propKind = getDeclarationKindFromSymbol(p);
-                        return propKind !== SyntaxKind.MethodDeclaration && propKind !== SyntaxKind.MethodSignature;
-                    });
-                    if (hasNonMethodDeclaration) {
+                    if (symbolHasNonMethodDeclaration(prop)) {
                         error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
                         return false;
                     }
@@ -14815,6 +14845,16 @@ namespace ts {
                 }
             }
 
+            // Referencing Abstract Properties within Constructors is not allowed
+            if ((flags & ModifierFlags.Abstract) && symbolHasNonMethodDeclaration(prop)) {
+                const declaringClassDeclaration = <ClassLikeDeclaration>getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
+
+                if (declaringClassDeclaration && isNodeWithinConstructor(node, declaringClassDeclaration)) {
+                    error(errorNode, Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, symbolToString(prop), typeToString(getDeclaringClass(prop)));
+                    return false;
+                }
+            }
+
             // Public properties are otherwise accessible.
             if (!(flags & ModifierFlags.NonPublicAccessibilityModifier)) {
                 return true;
@@ -14866,6 +14906,13 @@ namespace ts {
             return true;
         }
 
+        function symbolHasNonMethodDeclaration(symbol: Symbol) {
+            return forEachProperty(symbol, prop => {
+                const propKind = getDeclarationKindFromSymbol(prop);
+                return propKind !== SyntaxKind.MethodDeclaration && propKind !== SyntaxKind.MethodSignature;
+            });
+        }
+
         function checkNonNullExpression(node: Expression | QualifiedName) {
             return checkNonNullType(checkExpression(node), node);
         }
@@ -16548,6 +16595,12 @@ namespace ts {
                 return resolveUntypedCall(node);
             }
 
+            if (isPotentiallyUncalledDecorator(node, callSignatures)) {
+                const nodeStr = getTextOfNode(node.expression, /*includeTrivia*/ false);
+                error(node, Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr);
+                return resolveErrorCall(node);
+            }
+
             const headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
             if (!callSignatures.length) {
                 let errorInfo: DiagnosticMessageChain;
@@ -16560,6 +16613,18 @@ namespace ts {
             return resolveCall(node, callSignatures, candidatesOutArray, headMessage);
         }
 
+        /**
+         * Sometimes, we have a decorator that could accept zero arguments,
+         * but is receiving too many arguments as part of the decorator invocation.
+         * In those cases, a user may have meant to *call* the expression before using it as a decorator.
+         */
+        function isPotentiallyUncalledDecorator(decorator: Decorator, signatures: Signature[]) {
+            return signatures.length && every(signatures, signature =>
+                signature.minArgumentCount === 0 &&
+                !signature.hasRestParameter &&
+                signature.parameters.length < getEffectiveArgumentCount(decorator, /*args*/ undefined, signature));
+        }
+
         /**
          * This function is similar to getResolvedSignature but is exclusively for trying to resolve JSX stateless-function component.
          * The main reason we have to use this function instead of getResolvedSignature because, the caller of this function will already check the type of openingLikeElement's tagName
@@ -18433,9 +18498,8 @@ namespace ts {
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
 
             checkVariableLikeDeclaration(node);
-            let func = getContainingFunction(node);
+            const func = getContainingFunction(node);
             if (hasModifier(node, ModifierFlags.ParameterPropertyModifier)) {
-                func = getContainingFunction(node);
                 if (!(func.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) {
                     error(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
                 }
@@ -19968,14 +20032,20 @@ namespace ts {
         }
 
         function checkJSDocAugmentsTag(node: JSDocAugmentsTag): void {
-            const cls = getJSDocHost(node);
-            if (!isClassDeclaration(cls) && !isClassExpression(cls)) {
-                error(cls, Diagnostics.JSDoc_augments_is_not_attached_to_a_class_declaration);
+            const classLike = getJSDocHost(node);
+            if (!isClassDeclaration(classLike) && !isClassExpression(classLike)) {
+                error(classLike, Diagnostics.JSDoc_augments_is_not_attached_to_a_class_declaration);
                 return;
             }
 
+            const augmentsTags = getAllJSDocTagsOfKind(classLike, SyntaxKind.JSDocAugmentsTag);
+            Debug.assert(augmentsTags.length > 0);
+            if (augmentsTags.length > 1) {
+                error(augmentsTags[1], Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag);
+            }
+
             const name = getIdentifierFromEntityNameExpression(node.class.expression);
-            const extend = getClassExtendsHeritageClauseElement(cls);
+            const extend = getClassExtendsHeritageClauseElement(classLike);
             if (extend) {
                 const className = getIdentifierFromEntityNameExpression(extend.expression);
                 if (className && name.escapedText !== className.escapedText) {
@@ -20251,7 +20321,7 @@ namespace ts {
 
         function checkCollisionWithArgumentsInGeneratedCode(node: SignatureDeclaration) {
             // no rest parameters \ declaration context \ overload - no codegen impact
-            if (!hasDeclaredRestParameter(node) || isInAmbientContext(node) || nodeIsMissing((<FunctionLikeDeclaration>node).body)) {
+            if (!hasRestParameter(node) || isInAmbientContext(node) || nodeIsMissing((<FunctionLikeDeclaration>node).body)) {
                 return;
             }
 
@@ -23092,6 +23162,19 @@ namespace ts {
             return result;
         }
 
+        function isNodeWithinConstructor(node: Node, classDeclaration: ClassLikeDeclaration) {
+            return findAncestor(node, element => {
+                if (isConstructorDeclaration(element) && nodeIsPresent(element.body)) {
+                    return true;
+                }
+                else if (element === classDeclaration || isFunctionLikeDeclaration(element)) {
+                    return "quit";
+                }
+
+                return false;
+            });
+        }
+
         function isNodeWithinClass(node: Node, classDeclaration: ClassLikeDeclaration) {
             return !!forEachEnclosingClass(node, n => n === classDeclaration);
         }

src/compiler/diagnosticMessages.json

@@ -907,6 +907,10 @@
         "category": "Error",
         "code": 1328
     },
+    "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?": {
+        "category": "Error",
+        "code": 1329
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
@@ -2216,6 +2220,10 @@
         "category": "Error",
         "code": 2714
     },
+    "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor.": {
+        "category": "Error",
+        "code": 2715
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -3523,6 +3531,10 @@
         "category": "Error",
         "code": 8024
     },
+    "Class declarations cannot have more than one `@augments` or `@extends` tag.": {
+        "category": "Error",
+        "code": 8025
+    },
     "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause.": {
         "category": "Error",
         "code": 9002
@@ -3705,6 +3717,10 @@
         "category": "Message",
         "code": 90027
     },
+    "Call decorator expression.": {
+        "category": "Message",
+        "code": 90028
+    },
 
     "Convert function to an ES2015 class": {
         "category": "Message",

src/compiler/parser.ts

@@ -6373,6 +6373,7 @@ namespace ts {
                     if (tagName) {
                         switch (tagName.escapedText) {
                             case "augments":
+                            case "extends":
                                 tag = parseAugmentsTag(atToken, tagName);
                                 break;
                             case "class":
@@ -6699,7 +6700,7 @@ namespace ts {
                             if (typeExpression && typeExpression.type.kind === SyntaxKind.ArrayType) {
                                 jsdocTypeLiteral.isArrayType = true;
                             }
-                            typedefTag.typeExpression = childTypeTag && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
+                            typedefTag.typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
                                 childTypeTag.typeExpression :
                                 finishNode(jsdocTypeLiteral);
                         }

src/compiler/program.ts

@@ -1092,11 +1092,18 @@ namespace ts {
                 return true;
             }
 
-            if (defaultLibraryPath && defaultLibraryPath.length !== 0) {
-                return containsPath(defaultLibraryPath, file.path, currentDirectory, /*ignoreCase*/ !host.useCaseSensitiveFileNames());
+            if (!options.noLib) {
+                return false;
             }
 
-            return compareStrings(file.fileName, getDefaultLibraryFileName(), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
+            // If '--lib' is not specified, include default library file according to '--target'
+            // otherwise, using options specified in '--lib' instead of '--target' default library file
+            if (!options.lib) {
+               return compareStrings(file.fileName, getDefaultLibraryFileName(), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
+            }
+            else {
+                return forEach(options.lib, libFileName => compareStrings(file.fileName, combinePaths(defaultLibraryPath, libFileName), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo);
+            }
         }
 
         function getDiagnosticsProducingTypeChecker() {

src/compiler/transformers/module/module.ts

@@ -561,46 +561,89 @@ namespace ts {
             // });
             const resolve = createUniqueName("resolve");
             const reject = createUniqueName("reject");
-            return createNew(
-                createIdentifier("Promise"),
-                /*typeArguments*/ undefined,
-                [createFunctionExpression(
+            const parameters = [
+                createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),
+                createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)
+            ];
+            const body = createBlock([
+                createStatement(
+                    createCall(
+                        createIdentifier("require"),
+                        /*typeArguments*/ undefined,
+                        [createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject]
+                    )
+                )
+            ]);
+
+            let func: FunctionExpression | ArrowFunction;
+            if (languageVersion >= ScriptTarget.ES2015) {
+                func = createArrowFunction(
+                    /*modifiers*/ undefined,
+                    /*typeParameters*/ undefined,
+                    parameters,
+                    /*type*/ undefined,
+                    /*equalsGreaterThanToken*/ undefined,
+                    body);
+            }
+            else {
+                func = 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)],
+                    parameters,
                     /*type*/ undefined,
-                    createBlock([createStatement(
-                        createCall(
-                            createIdentifier("require"),
-                            /*typeArguments*/ undefined,
-                            [createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject]
-                        ))])
-            )]);
+                    body);
+
+                // if there is a lexical 'this' in the import call arguments, ensure we indicate
+                // that this new function expression indicates it captures 'this' so that the
+                // es2015 transformer will properly substitute 'this' with '_this'.
+                if (node.transformFlags & TransformFlags.ContainsLexicalThis) {
+                    setEmitFlags(func, EmitFlags.CapturesThis);
+                }
+            }
+
+            return createNew(createIdentifier("Promise"), /*typeArguments*/ undefined, [func]);
         }
 
-    function transformImportCallExpressionCommonJS(node: ImportCall): Expression {
+        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(
+            const promiseResolveCall = createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []);
+            const requireCall = createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments);
+
+            let func: FunctionExpression | ArrowFunction;
+            if (languageVersion >= ScriptTarget.ES2015) {
+                func = createArrowFunction(
+                    /*modifiers*/ undefined,
+                    /*typeParameters*/ undefined,
+                    /*parameters*/ [],
+                    /*type*/ undefined,
+                    /*equalsGreaterThanToken*/ undefined,
+                    requireCall);
+            }
+            else {
+                func = createFunctionExpression(
                     /*modifiers*/ undefined,
                     /*asteriskToken*/ undefined,
                     /*name*/ undefined,
                     /*typeParameters*/ undefined,
-                    /*parameters*/ undefined,
+                    /*parameters*/ [],
                     /*type*/ undefined,
-                    createBlock([createReturn(createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments))])
-                )]);
+                    createBlock([createReturn(requireCall)]));
+
+                // if there is a lexical 'this' in the import call arguments, ensure we indicate
+                // that this new function expression indicates it captures 'this' so that the
+                // es2015 transformer will properly substitute 'this' with '_this'.
+                if (node.transformFlags & TransformFlags.ContainsLexicalThis) {
+                    setEmitFlags(func, EmitFlags.CapturesThis);
+                }
+            }
+
+            return createCall(createPropertyAccess(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]);
         }
 
         /**
@@ -861,10 +904,10 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
+                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), visitNode(node.expression, importCallExpressionVisitor), /*location*/ node, /*allowComments*/ true);
             }
             else {
-                statements = appendExportStatement(statements, createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
+                statements = appendExportStatement(statements, createIdentifier("default"), visitNode(node.expression, importCallExpressionVisitor), /*location*/ node, /*allowComments*/ true);
             }
 
             return singleOrMany(statements);

src/compiler/types.ts

@@ -2159,6 +2159,10 @@ namespace ts {
         kind: SyntaxKind.JSDocTag;
     }
 
+    /**
+     * Note that `@extends` is a synonym of `@augments`.
+     * Both tags are represented by this interface.
+     */
     export interface JSDocAugmentsTag extends JSDocTag {
         kind: SyntaxKind.JSDocAugmentsTag;
         class: ExpressionWithTypeArguments & { expression: Identifier | PropertyAccessEntityNameExpression };
@@ -2194,7 +2198,7 @@ namespace ts {
     export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
         parent: JSDoc;
         name: EntityName;
-        typeExpression: JSDocTypeExpression;
+        typeExpression?: JSDocTypeExpression;
         /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
         isNameFirst: boolean;
         isBracketed: boolean;
@@ -2649,6 +2653,10 @@ namespace ts {
         signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        /**
+         * @deprecated Use the createX factory functions or XToY typechecker methods and `createPrinter` or the `xToString` methods instead
+         * This will be removed in a future version.
+         */
         getSymbolDisplayBuilder(): SymbolDisplayBuilder;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];

src/compiler/utilities.ts

@@ -1604,26 +1604,12 @@ namespace ts {
     }
 
     export function hasRestParameter(s: SignatureDeclaration): boolean {
-        return isRestParameter(lastOrUndefined(s.parameters));
+        const last = lastOrUndefined(s.parameters);
+        return last && isRestParameter(last);
     }
 
-    export function hasDeclaredRestParameter(s: SignatureDeclaration): boolean {
-        return isDeclaredRestParam(lastOrUndefined(s.parameters));
-    }
-
-    export function isRestParameter(node: ParameterDeclaration) {
-        if (isInJavaScriptFile(node)) {
-            if (node.type && node.type.kind === SyntaxKind.JSDocVariadicType ||
-                forEach(getJSDocParameterTags(node),
-                    t => t.typeExpression && t.typeExpression.type.kind === SyntaxKind.JSDocVariadicType)) {
-                return true;
-            }
-        }
-        return isDeclaredRestParam(node);
-    }
-
-    export function isDeclaredRestParam(node: ParameterDeclaration) {
-        return node && node.dotDotDotToken !== undefined;
+    export function isRestParameter(node: ParameterDeclaration): boolean {
+        return node.dotDotDotToken !== undefined;
     }
 
     export const enum AssignmentKind {
@@ -4112,27 +4098,35 @@ namespace ts {
         if (!declaration) {
             return undefined;
         }
-        if (isJSDocPropertyLikeTag(declaration) && declaration.name.kind === SyntaxKind.QualifiedName) {
-            return declaration.name.right;
-        }
-        if (declaration.kind === SyntaxKind.BinaryExpression) {
-            const expr = declaration as BinaryExpression;
-            switch (getSpecialPropertyAssignmentKind(expr)) {
-                case SpecialPropertyAssignmentKind.ExportsProperty:
-                case SpecialPropertyAssignmentKind.ThisProperty:
-                case SpecialPropertyAssignmentKind.Property:
-                case SpecialPropertyAssignmentKind.PrototypeProperty:
-                    return (expr.left as PropertyAccessExpression).name;
-                default:
-                    return undefined;
+        switch (declaration.kind) {
+            case SyntaxKind.JSDocPropertyTag:
+            case SyntaxKind.JSDocParameterTag: {
+                const { name } = declaration as JSDocPropertyLikeTag;
+                if (name.kind === SyntaxKind.QualifiedName) {
+                    return name.right;
+                }
+                break;
+            }
+            case SyntaxKind.BinaryExpression: {
+                const expr = declaration as BinaryExpression;
+                switch (getSpecialPropertyAssignmentKind(expr)) {
+                    case SpecialPropertyAssignmentKind.ExportsProperty:
+                    case SpecialPropertyAssignmentKind.ThisProperty:
+                    case SpecialPropertyAssignmentKind.Property:
+                    case SpecialPropertyAssignmentKind.PrototypeProperty:
+                        return (expr.left as PropertyAccessExpression).name;
+                    default:
+                        return undefined;
+                }
+            }
+            case SyntaxKind.JSDocTypedefTag:
+                return getNameOfJSDocTypedef(declaration as JSDocTypedefTag);
+            case SyntaxKind.ExportAssignment: {
+                const { expression } = declaration as ExportAssignment;
+                return isIdentifier(expression) ? expression : undefined;
             }
         }
-        else if (declaration.kind === SyntaxKind.JSDocTypedefTag) {
-            return getNameOfJSDocTypedef(declaration as JSDocTypedefTag);
-        }
-        else {
-            return (declaration as NamedDeclaration).name;
-        }
+        return (declaration as NamedDeclaration).name;
     }
 
     /**
@@ -4247,6 +4241,12 @@ namespace ts {
         return find(tags, doc => doc.kind === kind);
     }
 
+    /** Gets all JSDoc tags of a specified kind, or undefined if not present. */
+    export function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): ReadonlyArray<JSDocTag> | undefined {
+        const tags = getJSDocTags(node);
+        return filter(tags, doc => doc.kind === kind);
+    }
+
 }
 
 // Simple node tests of the form `node.kind === SyntaxKind.Foo`.

src/compiler/watch.ts

@@ -249,10 +249,10 @@ namespace ts {
         let hasChangedAutomaticTypeDirectiveNames = false;                  // True if the automatic type directives have changed
 
         const loggingEnabled = compilerOptions.diagnostics || compilerOptions.extendedDiagnostics;
-        const writeLog: (s: string) => void = loggingEnabled ? s => system.write(s) : noop;
-        const watchFile = loggingEnabled ? ts.addFileWatcherWithLogging : ts.addFileWatcher;
-        const watchFilePath = loggingEnabled ? ts.addFilePathWatcherWithLogging : ts.addFilePathWatcher;
-        const watchDirectoryWorker = loggingEnabled ? ts.addDirectoryWatcherWithLogging : ts.addDirectoryWatcher;
+        const writeLog: (s: string) => void = loggingEnabled ? s => { system.write(s); system.write(system.newLine); } : noop;
+        const watchFile = compilerOptions.extendedDiagnostics ? ts.addFileWatcherWithLogging : loggingEnabled ? ts.addFileWatcherWithOnlyTriggerLogging : ts.addFileWatcher;
+        const watchFilePath = compilerOptions.extendedDiagnostics ? ts.addFilePathWatcherWithLogging : ts.addFilePathWatcher;
+        const watchDirectoryWorker = compilerOptions.extendedDiagnostics ? ts.addDirectoryWatcherWithLogging : ts.addDirectoryWatcher;
 
         watchingHost = watchingHost || createWatchingSystemHost(compilerOptions.pretty);
         const { system, parseConfigFile, reportDiagnostic, reportWatchDiagnostic, beforeCompile, afterCompile } = watchingHost;

src/compiler/watchUtilities.ts

@@ -82,7 +82,12 @@ namespace ts {
 
     export function addFileWatcherWithLogging(host: System, file: string, cb: FileWatcherCallback, log: (s: string) => void): FileWatcher {
         const watcherCaption = `FileWatcher:: `;
-        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, host, file, cb);
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, file, cb);
+    }
+
+    export function addFileWatcherWithOnlyTriggerLogging(host: System, file: string, cb: FileWatcherCallback, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `FileWatcher:: `;
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, file, cb);
     }
 
     export type FilePathWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind, filePath: Path) => void;
@@ -92,7 +97,12 @@ namespace ts {
 
     export function addFilePathWatcherWithLogging(host: System, file: string, cb: FilePathWatcherCallback, path: Path, log: (s: string) => void): FileWatcher {
         const watcherCaption = `FileWatcher:: `;
-        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, host, file, cb, path);
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, file, cb, path);
+    }
+
+    export function addFilePathWatcherWithOnlyTriggerLogging(host: System, file: string, cb: FilePathWatcherCallback, path: Path, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `FileWatcher:: `;
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, file, cb, path);
     }
 
     export function addDirectoryWatcher(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags): FileWatcher {
@@ -102,14 +112,21 @@ namespace ts {
 
     export function addDirectoryWatcherWithLogging(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags, log: (s: string) => void): FileWatcher {
         const watcherCaption = `DirectoryWatcher ${(flags & WatchDirectoryFlags.Recursive) !== 0 ? "recursive" : ""}:: `;
-        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, host, directory, cb, flags);
+        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, directory, cb, flags);
+    }
+
+    export function addDirectoryWatcherWithOnlyTriggerLogging(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `DirectoryWatcher ${(flags & WatchDirectoryFlags.Recursive) !== 0 ? "recursive" : ""}:: `;
+        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, directory, cb, flags);
     }
 
     type WatchCallback<T, U> = (fileName: string, cbOptional1?: T, optional?: U) => void;
     type AddWatch<T, U> = (host: System, file: string, cb: WatchCallback<T, U>, optional?: U) => FileWatcher;
-    function createWatcherWithLogging<T, U>(addWatch: AddWatch<T, U>, watcherCaption: string, log: (s: string) => void, host: System, file: string, cb: WatchCallback<T, U>, optional?: U): FileWatcher {
+    function createWatcherWithLogging<T, U>(addWatch: AddWatch<T, U>, watcherCaption: string, log: (s: string) => void, logOnlyTrigger: boolean, host: System, file: string, cb: WatchCallback<T, U>, optional?: U): FileWatcher {
         const info = `PathInfo: ${file}`;
-        log(`${watcherCaption}Added: ${info}`);
+        if (!logOnlyTrigger) {
+            log(`${watcherCaption}Added: ${info}`);
+        }
         const watcher = addWatch(host, file, (fileName, cbOptional1?) => {
             const optionalInfo = cbOptional1 !== undefined ? ` ${cbOptional1}` : "";
             log(`${watcherCaption}Trigger: ${fileName}${optionalInfo} ${info}`);
@@ -120,7 +137,9 @@ namespace ts {
         }, optional);
         return {
             close: () => {
-                log(`${watcherCaption}Close: ${info}`);
+                if (!logOnlyTrigger) {
+                    log(`${watcherCaption}Close: ${info}`);
+                }
                 watcher.close();
             }
         };

src/harness/unittests/compileOnSave.ts

@@ -563,7 +563,7 @@ namespace ts.projectSystem {
                 path: "/a/b/file3.js",
                 content: "console.log('file3');"
             };
-            const externalProjectName = "externalproject";
+            const externalProjectName = "/a/b/externalproject";
             const host = createServerHost([file1, file2, file3, libFile]);
             const session = createSession(host);
             const projectService = session.getProjectService();
@@ -588,5 +588,48 @@ namespace ts.projectSystem {
             assert.isTrue(outFileContent.indexOf(file2.content) === -1);
             assert.isTrue(outFileContent.indexOf(file3.content) === -1);
         });
+
+        it("should use project root as current directory so that compile on save results in correct file mapping", () => {
+            const inputFileName = "Foo.ts";
+            const file1 = {
+                path: `/root/TypeScriptProject3/TypeScriptProject3/${inputFileName}`,
+                content: "consonle.log('file1');"
+            };
+            const externalProjectName = "/root/TypeScriptProject3/TypeScriptProject3/TypeScriptProject3.csproj";
+            const host = createServerHost([file1, libFile]);
+            const session = createSession(host);
+            const projectService = session.getProjectService();
+
+            const outFileName = "bar.js";
+            projectService.openExternalProject({
+                rootFiles: toExternalFiles([file1.path]),
+                options: {
+                    outFile: outFileName,
+                    sourceMap: true,
+                    compileOnSave: true
+                },
+                projectFileName: externalProjectName
+            });
+
+            const emitRequest = makeSessionRequest<server.protocol.CompileOnSaveEmitFileRequestArgs>(CommandNames.CompileOnSaveEmitFile, { file: file1.path });
+            session.executeCommand(emitRequest);
+
+            // Verify js file
+            const expectedOutFileName = "/root/TypeScriptProject3/TypeScriptProject3/" + outFileName;
+            assert.isTrue(host.fileExists(expectedOutFileName));
+            const outFileContent = host.readFile(expectedOutFileName);
+            verifyContentHasString(outFileContent, file1.content);
+            verifyContentHasString(outFileContent, `//# sourceMappingURL=${outFileName}.map`);
+
+            // Verify map file
+            const expectedMapFileName = expectedOutFileName + ".map";
+            assert.isTrue(host.fileExists(expectedMapFileName));
+            const mapFileContent = host.readFile(expectedMapFileName);
+            verifyContentHasString(mapFileContent, `"sources":["${inputFileName}"]`);
+
+            function verifyContentHasString(content: string, string: string) {
+                assert.isTrue(content.indexOf(string) !== -1, `Expected "${content}" to have "${string}"`);
+            }
+        });
     });
 }

src/harness/unittests/publicApi.ts

@@ -1,10 +1,34 @@
 /// <reference path="../harness.ts" />
 
 describe("Public APIs", () => {
-    it("for the language service and compiler should be acknowledged when they change", () => {
-        Harness.Baseline.runBaseline("api/typescript.d.ts", () => Harness.IO.readFile("built/local/typescript.d.ts"));
+    function verifyApi(fileName: string) {
+        const builtFile = `built/local/${fileName}`;
+        const api = `api/${fileName}`;
+        let fileContent: string;
+        before(() => {
+            fileContent = Harness.IO.readFile(builtFile);
+        });
+
+        it("should be acknowledged when they change", () => {
+            Harness.Baseline.runBaseline(api, () => fileContent);
+        });
+
+        it("should compile", () => {
+            const testFile: Harness.Compiler.TestFile = {
+                unitName: builtFile,
+                content: fileContent
+            };
+            const inputFiles = [testFile];
+            const output = Harness.Compiler.compileFiles(inputFiles, [], /*harnessSettings*/ undefined, /*options*/ {}, /*currentDirectory*/ undefined);
+            assert(!output.result.errors || !output.result.errors.length, Harness.Compiler.minimalDiagnosticsToString(output.result.errors, /*pretty*/ true));
+        });
+    }
+
+    describe("for the language service and compiler", () => {
+        verifyApi("typescript.d.ts");
     });
-    it("for the language server should be acknowledged when they change", () => {
-        Harness.Baseline.runBaseline("api/tsserverlibrary.d.ts", () => Harness.IO.readFile("built/local/tsserverlibrary.d.ts"));
+
+    describe("for the language server", () => {
+        verifyApi("tsserverlibrary.d.ts");
     });
-});
+});

src/harness/unittests/session.ts

@@ -16,8 +16,8 @@ namespace ts.server {
         directoryExists: () => false,
         getDirectories: () => [],
         createDirectory: noop,
-        getExecutingFilePath(): string { return void 0; },
-        getCurrentDirectory(): string { return void 0; },
+        getExecutingFilePath(): string { return ""; },
+        getCurrentDirectory(): string { return ""; },
         getEnvironmentVariable(): string { return ""; },
         readDirectory() { return []; },
         exit: noop,
@@ -386,6 +386,61 @@ namespace ts.server {
         });
     });
 
+    describe("exceptions", () => {
+        const command = "testhandler";
+        class TestSession extends Session {
+            lastSent: protocol.Message;
+            private exceptionRaisingHandler(_request: protocol.Request): { response?: any, responseRequired: boolean } {
+                f1();
+                return;
+                function f1() {
+                    throw new Error("myMessage");
+                }
+            }
+
+            constructor() {
+                super({
+                    host: mockHost,
+                    cancellationToken: nullCancellationToken,
+                    useSingleInferredProject: false,
+                    useInferredProjectPerProjectRoot: false,
+                    typingsInstaller: undefined,
+                    byteLength: Utils.byteLength,
+                    hrtime: process.hrtime,
+                    logger: projectSystem.nullLogger,
+                    canUseEvents: true
+                });
+                this.addProtocolHandler(command, this.exceptionRaisingHandler);
+            }
+            send(msg: protocol.Message) {
+                this.lastSent = msg;
+            }
+        }
+
+        it("raised in a protocol handler generate an event", () => {
+
+            const session = new TestSession();
+
+            const request = {
+                command,
+                seq: 0,
+                type: "request"
+            };
+
+            session.onMessage(JSON.stringify(request));
+            const lastSent = session.lastSent as protocol.Response;
+
+            expect(lastSent).to.contain({
+                seq: 0,
+                type: "response",
+                command,
+                success: false
+            });
+
+            expect(lastSent.message).has.string("myMessage").and.has.string("f1");
+        });
+    });
+
     describe("how Session is extendable via subclassing", () => {
         class TestSession extends Session {
             lastSent: protocol.Message;

src/harness/unittests/tsserverProjectSystem.ts

@@ -352,8 +352,6 @@ namespace ts.projectSystem {
         verifyDiagnostics(actual, []);
     }
 
-    const typeRootFromTsserverLocation = "/node_modules/@types";
-
     export function getTypeRootsFromLocation(currentDirectory: string) {
         currentDirectory = normalizePath(currentDirectory);
         const result: string[] = [];
@@ -401,7 +399,7 @@ namespace ts.projectSystem {
             const configFiles = flatMap(configFileLocations, location => [location + "tsconfig.json", location + "jsconfig.json"]);
             checkWatchedFiles(host, configFiles.concat(libFile.path, moduleFile.path));
             checkWatchedDirectories(host, [], /*recursive*/ false);
-            checkWatchedDirectories(host, ["/a/b/c", typeRootFromTsserverLocation], /*recursive*/ true);
+            checkWatchedDirectories(host, ["/a/b/c", ...getTypeRootsFromLocation(getDirectoryPath(appFile.path))], /*recursive*/ true);
         });
 
         it("can handle tsconfig file name with difference casing", () => {
@@ -4394,7 +4392,7 @@ namespace ts.projectSystem {
 
             function verifyCalledOnEachEntry(callback: CalledMaps, expectedKeys: Map<number>) {
                 const calledMap = calledMaps[callback];
-                assert.equal(calledMap.size, expectedKeys.size, `${callback}: incorrect size of map: Actual keys: ${arrayFrom(calledMap.keys())} Expected: ${arrayFrom(expectedKeys.keys())}`);
+                ts.TestFSWithWatch.verifyMapSize(callback, calledMap, arrayFrom(expectedKeys.keys()));
                 expectedKeys.forEach((called, name) => {
                     assert.isTrue(calledMap.has(name), `${callback} is expected to contain ${name}, actual keys: ${arrayFrom(calledMap.keys())}`);
                     assert.equal(calledMap.get(name).length, called, `${callback} is expected to be called ${called} times with ${name}. Actual entry: ${calledMap.get(name)}`);
@@ -4476,6 +4474,7 @@ namespace ts.projectSystem {
             }
             const f2Lookups = getLocationsForModuleLookup("f2");
             callsTrackingHost.verifyCalledOnEachEntryNTimes(CalledMapsWithSingleArg.fileExists, f2Lookups, 1);
+            const typeRootLocations = getTypeRootsFromLocation(getDirectoryPath(root.path));
             const f2DirLookups = getLocationsForDirectoryLookup();
             callsTrackingHost.verifyCalledOnEachEntry(CalledMapsWithSingleArg.directoryExists, f2DirLookups);
             callsTrackingHost.verifyNoCall(CalledMapsWithSingleArg.getDirectories);
@@ -4486,7 +4485,7 @@ namespace ts.projectSystem {
             verifyImportedDiagnostics();
             const f1Lookups = f2Lookups.map(s => s.replace("f2", "f1"));
             f1Lookups.length = f1Lookups.indexOf(imported.path) + 1;
-            const f1DirLookups = ["/c/d", "/c", typeRootFromTsserverLocation];
+            const f1DirLookups = ["/c/d", "/c", ...typeRootLocations];
             vertifyF1Lookups();
 
             // setting compiler options discards module resolution cache
@@ -4538,7 +4537,7 @@ namespace ts.projectSystem {
             function getLocationsForDirectoryLookup() {
                 const result = createMap<number>();
                 // Type root
-                result.set(typeRootFromTsserverLocation, 1);
+                typeRootLocations.forEach(location => result.set(location, 1));
                 forEachAncestorDirectory(getDirectoryPath(root.path), ancestor => {
                     // To resolve modules
                     result.set(ancestor, 2);

src/harness/virtualFileSystemWithWatch.ts

@@ -95,7 +95,7 @@ namespace ts.TestFSWithWatch {
         }
     }
 
-    function getDiffInKeys(map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+    function getDiffInKeys<T>(map: Map<T>, expectedKeys: ReadonlyArray<string>) {
         if (map.size === expectedKeys.length) {
             return "";
         }
@@ -122,8 +122,12 @@ namespace ts.TestFSWithWatch {
         return `\n\nNotInActual: ${notInActual}\nDuplicates: ${duplicates}\nInActualButNotInExpected: ${inActualNotExpected}`;
     }
 
-    function checkMapKeys(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+    export function verifyMapSize(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
         assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map: Actual keys: ${arrayFrom(map.keys())} Expected: ${expectedKeys}${getDiffInKeys(map, expectedKeys)}`);
+    }
+
+    function checkMapKeys(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+        verifyMapSize(caption, map, expectedKeys);
         for (const name of expectedKeys) {
             assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${arrayFrom(map.keys())}`);
         }
@@ -548,7 +552,7 @@ namespace ts.TestFSWithWatch {
             const folder = this.toFolder(directoryName);
 
             // base folder has to be present
-            const base = getDirectoryPath(folder.fullPath);
+            const base = getDirectoryPath(folder.path);
             const baseFolder = this.fs.get(base) as Folder;
             Debug.assert(isFolder(baseFolder));
 
@@ -560,7 +564,7 @@ namespace ts.TestFSWithWatch {
             const file = this.toFile({ path, content });
 
             // base folder has to be present
-            const base = getDirectoryPath(file.fullPath);
+            const base = getDirectoryPath(file.path);
             const folder = this.fs.get(base) as Folder;
             Debug.assert(isFolder(folder));
 

src/lib/es2015.core.d.ts

@@ -10,6 +10,7 @@ interface Array<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
+    find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
     find(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined;
 
     /**
@@ -350,6 +351,7 @@ interface ReadonlyArray<T> {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
+    find<S extends T>(predicate: (this: void, value: T, index: number, obj: ReadonlyArray<T>) => value is S, thisArg?: any): S | undefined;
     find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
 
     /**

src/lib/es2017.object.d.ts

@@ -3,7 +3,7 @@ interface ObjectConstructor {
      * Returns an array of values of the enumerable properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
-    values<T>(o: { [s: string]: T }): T[];
+    values<T>(o: { [s: string]: T } | { [n: number]: T }): T[];
 
     /**
      * Returns an array of values of the enumerable properties of an object
@@ -15,7 +15,7 @@ interface ObjectConstructor {
      * Returns an array of key/values of the enumerable properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
-    entries<T>(o: { [s: string]: T }): [string, T][];
+    entries<T>(o: { [s: string]: T } | { [n: number]: T }): [string, T][];
 
     /**
      * Returns an array of key/values of the enumerable properties of an object

src/lib/es5.d.ts

@@ -1050,7 +1050,8 @@ interface ReadonlyArray<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue?: T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1062,7 +1063,8 @@ interface ReadonlyArray<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue?: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
@@ -1200,7 +1202,8 @@ interface Array<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1212,7 +1215,8 @@ interface Array<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
@@ -1647,7 +1651,8 @@ interface Int8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1671,7 +1676,8 @@ interface Int8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -1914,7 +1920,8 @@ interface Uint8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1938,7 +1945,8 @@ interface Uint8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2181,7 +2189,8 @@ interface Uint8ClampedArray {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2205,7 +2214,8 @@ interface Uint8ClampedArray {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2446,7 +2456,8 @@ interface Int16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2470,7 +2481,8 @@ interface Int16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2714,7 +2726,8 @@ interface Uint16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2738,7 +2751,8 @@ interface Uint16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2981,7 +2995,8 @@ interface Int32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3005,7 +3020,8 @@ interface Int32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3247,7 +3263,8 @@ interface Uint32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3271,7 +3288,8 @@ interface Uint32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3514,7 +3532,8 @@ interface Float32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3538,7 +3557,8 @@ interface Float32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3782,7 +3802,8 @@ interface Float64Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3806,7 +3827,8 @@ interface Float64Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.

src/server/editorServices.ts

@@ -403,7 +403,7 @@ namespace ts.server {
             this.globalPlugins = opts.globalPlugins || emptyArray;
             this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;
             this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;
-            this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(this.host.getExecutingFilePath(), "../typesMap.json") : opts.typesMapLocation;
+            this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(this.getExecutingFilePath(), "../typesMap.json") : opts.typesMapLocation;
 
             Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService");
 
@@ -431,6 +431,11 @@ namespace ts.server {
                 this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithLogging(host, file, cb, path, this.createWatcherLog(watchType, project));
                 this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));
             }
+            else if (this.logger.loggingEnabled()) {
+                this.watchFile = (host, file, cb, watchType, project) => ts.addFileWatcherWithOnlyTriggerLogging(host, file, cb, this.createWatcherLog(watchType, project));
+                this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithOnlyTriggerLogging(host, file, cb, path, this.createWatcherLog(watchType, project));
+                this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithOnlyTriggerLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));
+            }
             else {
                 this.watchFile = ts.addFileWatcher;
                 this.watchFilePath = ts.addFilePathWatcher;
@@ -447,6 +452,16 @@ namespace ts.server {
             return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);
         }
 
+        /*@internal*/
+        getExecutingFilePath() {
+            return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath());
+        }
+
+        /*@internal*/
+        getNormalizedAbsolutePath(fileName: string) {
+            return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
+        }
+
         /* @internal */
         getChangedFiles_TestOnly() {
             return this.changedFiles;
@@ -1624,12 +1639,13 @@ namespace ts.server {
                 return this.inferredProjects[0];
             }
 
-            return this.createInferredProject(/*rootDirectoryForResolution*/ undefined, /*isSingleInferredProject*/ true);
+            // Single inferred project does not have a project root and hence no current directory
+            return this.createInferredProject(/*currentDirectory*/ undefined, /*isSingleInferredProject*/ true);
         }
 
-        private createInferredProject(rootDirectoryForResolution: string | undefined, isSingleInferredProject?: boolean, projectRootPath?: string): InferredProject {
+        private createInferredProject(currentDirectory: string | undefined, isSingleInferredProject?: boolean, projectRootPath?: string): InferredProject {
             const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects;
-            const project = new InferredProject(this, this.documentRegistry, compilerOptions, projectRootPath, rootDirectoryForResolution);
+            const project = new InferredProject(this, this.documentRegistry, compilerOptions, projectRootPath, currentDirectory);
             if (isSingleInferredProject) {
                 this.inferredProjects.unshift(project);
             }

src/server/project.ts

@@ -195,6 +195,9 @@ namespace ts.server {
             return result.module;
         }
 
+        /*@internal*/
+        readonly currentDirectory: string;
+
         /*@internal*/
         constructor(
             /*@internal*/readonly projectName: string,
@@ -206,7 +209,8 @@ namespace ts.server {
             private compilerOptions: CompilerOptions,
             public compileOnSaveEnabled: boolean,
             /*@internal*/public directoryStructureHost: DirectoryStructureHost,
-            rootDirectoryForResolution: string | undefined) {
+            currentDirectory: string | undefined) {
+            this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory || "");
 
             this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);
             if (!this.compilerOptions) {
@@ -230,7 +234,8 @@ namespace ts.server {
             }
 
             this.languageService = createLanguageService(this, this.documentRegistry);
-            this.resolutionCache = createResolutionCache(this, rootDirectoryForResolution);
+            // Use the current directory as resolution root only if the project created using current directory string
+            this.resolutionCache = createResolutionCache(this, currentDirectory && this.currentDirectory);
             if (!languageServiceEnabled) {
                 this.disableLanguageService();
             }
@@ -296,16 +301,16 @@ namespace ts.server {
             }
         }
 
-        getCancellationToken() {
+        getCancellationToken(): HostCancellationToken {
             return this.cancellationToken;
         }
 
         getCurrentDirectory(): string {
-            return this.directoryStructureHost.getCurrentDirectory();
+            return this.currentDirectory;
         }
 
         getDefaultLibFileName() {
-            const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.host.getExecutingFilePath()));
+            const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath()));
             return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions));
         }
 
@@ -448,9 +453,8 @@ namespace ts.server {
             this.ensureBuilder();
             const { emitSkipped, outputFiles } = this.builder.emitFile(this.program, scriptInfo.path);
             if (!emitSkipped) {
-                const projectRootPath = this.getProjectRootPath();
                 for (const outputFile of outputFiles) {
-                    const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, projectRootPath ? projectRootPath : getDirectoryPath(scriptInfo.fileName));
+                    const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, this.currentDirectory);
                     writeFile(outputFileAbsoluteFileName, outputFile.text, outputFile.writeByteOrderMark);
                 }
             }
@@ -479,7 +483,6 @@ namespace ts.server {
         getProjectName() {
             return this.projectName;
         }
-        abstract getProjectRootPath(): string | undefined;
         abstract getTypeAcquisition(): TypeAcquisition;
 
         getExternalFiles(): SortedReadonlyArray<string> {
@@ -561,7 +564,7 @@ namespace ts.server {
             return map(this.program.getSourceFiles(), sourceFile => {
                 const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.path);
                 if (!scriptInfo) {
-                    Debug.fail(`scriptInfo for a file '${sourceFile.fileName}' is missing.`);
+                    Debug.fail(`scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' is missing.`);
                 }
                 return scriptInfo;
             });
@@ -1042,8 +1045,8 @@ namespace ts.server {
             projectService: ProjectService,
             documentRegistry: DocumentRegistry,
             compilerOptions: CompilerOptions,
-            public readonly projectRootPath: string | undefined,
-            rootDirectoryForResolution: string | undefined) {
+            readonly projectRootPath: string | undefined,
+            currentDirectory: string | undefined) {
             super(InferredProject.newName(),
                 ProjectKind.Inferred,
                 projectService,
@@ -1053,7 +1056,7 @@ namespace ts.server {
                 compilerOptions,
                 /*compileOnSaveEnabled*/ false,
                 projectService.host,
-                rootDirectoryForResolution);
+                currentDirectory);
         }
 
         addRoot(info: ScriptInfo) {
@@ -1082,12 +1085,6 @@ namespace ts.server {
                 this.getRootScriptInfos().length === 1;
         }
 
-        getProjectRootPath() {
-            return this.projectRootPath ||
-                // Single inferred project does not have a project root.
-                !this.projectService.useSingleInferredProject && getDirectoryPath(this.getRootFiles()[0]);
-        }
-
         close() {
             forEach(this.getRootScriptInfos(), info => this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info));
             super.close();
@@ -1183,7 +1180,7 @@ namespace ts.server {
 
             // Search our peer node_modules, then any globally-specified probe paths
             // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
-            const searchPaths = [combinePaths(host.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations];
+            const searchPaths = [combinePaths(this.projectService.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations];
 
             if (this.projectService.allowLocalPluginLoads) {
                 const local = getDirectoryPath(this.canonicalConfigFilePath);
@@ -1263,10 +1260,6 @@ namespace ts.server {
             }
         }
 
-        getProjectRootPath() {
-            return getDirectoryPath(this.getConfigFilePath());
-        }
-
         /**
          * Get the errors that dont have any file name associated
          */
@@ -1381,13 +1374,14 @@ namespace ts.server {
             compilerOptions: CompilerOptions,
             languageServiceEnabled: boolean,
             public compileOnSaveEnabled: boolean,
-            private readonly projectFilePath?: string) {
+            projectFilePath?: string) {
             super(externalProjectName,
                 ProjectKind.External,
                 projectService,
                 documentRegistry,
                 /*hasExplicitListOfFiles*/ true,
-                languageServiceEnabled, compilerOptions,
+                languageServiceEnabled,
+                compilerOptions,
                 compileOnSaveEnabled,
                 projectService.host,
                 getDirectoryPath(projectFilePath || normalizeSlashes(externalProjectName)));
@@ -1397,16 +1391,6 @@ namespace ts.server {
             return this.excludedFiles;
         }
 
-        getProjectRootPath() {
-            if (this.projectFilePath) {
-                return getDirectoryPath(this.projectFilePath);
-            }
-            // if the projectFilePath is not given, we make the assumption that the project name
-            // is the path of the project file. AS the project name is provided by VS, we need to
-            // normalize slashes before using it as a file name.
-            return getDirectoryPath(normalizeSlashes(this.getProjectName()));
-        }
-
         getTypeAcquisition() {
             return this.typeAcquisition;
         }

src/services/codefixes/addMissingInvocationForDecorator.ts

@@ -0,0 +1,20 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0.code],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const token = getTokenAtPosition(sourceFile, context.span.start, /*includeJsDocComment*/ false);
+            const decorator = getAncestor(token, SyntaxKind.Decorator) as Decorator;
+            Debug.assert(!!decorator, "Expected position to be owned by a decorator.");
+            const replacement = createCall(decorator.expression, /*typeArguments*/ undefined, /*argumentsArray*/ undefined);
+            const changeTracker = textChanges.ChangeTracker.fromContext(context);
+            changeTracker.replaceNode(sourceFile, decorator.expression, replacement);
+
+            return [{
+                description: getLocaleSpecificMessage(Diagnostics.Call_decorator_expression),
+                changes: changeTracker.getChanges()
+            }];
+        }
+    });
+}

src/services/codefixes/fixes.ts

@@ -1,3 +1,4 @@
+/// <reference path="addMissingInvocationForDecorator.ts" />
 /// <reference path="correctQualifiedNameToIndexedAccessType.ts" />
 /// <reference path="fixClassIncorrectlyImplementsInterface.ts" />
 /// <reference path="fixAddMissingMember.ts" />

src/services/codefixes/importFixes.ts

@@ -16,7 +16,7 @@ namespace ts.codefix {
         moduleSpecifier?: string;
     }
 
-    enum ModuleSpecifierComparison {
+    const enum ModuleSpecifierComparison {
         Better,
         Equal,
         Worse
@@ -26,10 +26,6 @@ namespace ts.codefix {
         private symbolIdToActionMap: ImportCodeAction[][] = [];
 
         addAction(symbolId: number, newAction: ImportCodeAction) {
-            if (!newAction) {
-                return;
-            }
-
             const actions = this.symbolIdToActionMap[symbolId];
             if (!actions) {
                 this.symbolIdToActionMap[symbolId] = [newAction];

src/services/findAllReferences.ts

@@ -482,7 +482,10 @@ namespace ts.FindAllReferences.Core {
         /** @param allSearchSymbols set of additinal symbols for use by `includes`. */
         createSearch(location: Node, symbol: Symbol, comingFrom: ImportExport | undefined, searchOptions: { text?: string, allSearchSymbols?: Symbol[] } = {}): Search {
             // Note: if this is an external module symbol, the name doesn't include quotes.
-            const { text = stripQuotes(getDeclaredName(this.checker, symbol, location)), allSearchSymbols = undefined } = searchOptions;
+            const {
+                text = stripQuotes(unescapeLeadingUnderscores((getLocalSymbolForExportDefault(symbol) || symbol).escapedName)),
+                allSearchSymbols = undefined,
+            } = searchOptions;
             const escapedText = escapeLeadingUnderscores(text);
             const parents = this.options.implementations && getParentSymbolsOfPropertyAccess(location, symbol, this.checker);
             return {

src/services/importTracker.ts

@@ -609,9 +609,6 @@ namespace ts.FindAllReferences {
         }
 
         return forEach(symbol.declarations, decl => {
-            if (isExportAssignment(decl)) {
-                return isIdentifier(decl.expression) ? decl.expression.escapedText : undefined;
-            }
             const name = getNameOfDeclaration(decl);
             return name && name.kind === SyntaxKind.Identifier && name.escapedText;
         });

src/services/shims.ts

@@ -16,7 +16,7 @@
 /// <reference path='services.ts' />
 
 /* @internal */
-let debugObjectHost = (function (this: any) { return this; })();
+let debugObjectHost: { CollectGarbage(): void } = (function (this: any) { return this; })();
 
 // We need to use 'null' to interface with the managed side.
 /* tslint:disable:no-null-keyword */
@@ -119,13 +119,13 @@ namespace ts {
     }
 
     export interface Shim {
-        dispose(_dummy: any): void;
+        dispose(_dummy: {}): void;
     }
 
     export interface LanguageServiceShim extends Shim {
         languageService: LanguageService;
 
-        dispose(_dummy: any): void;
+        dispose(_dummy: {}): void;
 
         refresh(throwOnError: boolean): void;
 
@@ -417,7 +417,7 @@ namespace ts {
             return this.shimHost.getScriptVersion(fileName);
         }
 
-        public getLocalizedDiagnosticMessages(): any {
+        public getLocalizedDiagnosticMessages() {
             const diagnosticMessagesJson = this.shimHost.getLocalizedDiagnosticMessages();
             if (diagnosticMessagesJson === null || diagnosticMessagesJson === "") {
                 return null;
@@ -515,7 +515,7 @@ namespace ts {
         }
     }
 
-    function simpleForwardCall(logger: Logger, actionDescription: string, action: () => any, logPerformance: boolean): any {
+    function simpleForwardCall(logger: Logger, actionDescription: string, action: () => {}, logPerformance: boolean): {} {
         let start: number;
         if (logPerformance) {
             logger.log(actionDescription);
@@ -539,14 +539,14 @@ namespace ts {
         return result;
     }
 
-    function forwardJSONCall(logger: Logger, actionDescription: string, action: () => any, logPerformance: boolean): string {
+    function forwardJSONCall(logger: Logger, actionDescription: string, action: () => {}, logPerformance: boolean): string {
         return <string>forwardCall(logger, actionDescription, /*returnJson*/ true, action, logPerformance);
     }
 
     function forwardCall<T>(logger: Logger, actionDescription: string, returnJson: boolean, action: () => T, logPerformance: boolean): T | string {
         try {
             const result = simpleForwardCall(logger, actionDescription, action, logPerformance);
-            return returnJson ? JSON.stringify({ result }) : result;
+            return returnJson ? JSON.stringify({ result }) : result as T;
         }
         catch (err) {
             if (err instanceof OperationCanceledException) {
@@ -563,7 +563,7 @@ namespace ts {
         constructor(private factory: ShimFactory) {
             factory.registerShim(this);
         }
-        public dispose(_dummy: any): void {
+        public dispose(_dummy: {}): void {
             this.factory.unregisterShim(this);
         }
     }
@@ -601,7 +601,7 @@ namespace ts {
             this.logger = this.host;
         }
 
-        public forwardJSONCall(actionDescription: string, action: () => any): string {
+        public forwardJSONCall(actionDescription: string, action: () => {}): string {
             return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance);
         }
 
@@ -611,7 +611,7 @@ namespace ts {
          * Ensure (almost) deterministic release of internal Javascript resources when
          * some external native objects holds onto us (e.g. Com/Interop).
          */
-        public dispose(dummy: any): void {
+        public dispose(dummy: {}): void {
             this.logger.log("dispose()");
             this.languageService.dispose();
             this.languageService = null;
@@ -635,7 +635,7 @@ namespace ts {
         public refresh(throwOnError: boolean): void {
             this.forwardJSONCall(
                 `refresh(${throwOnError})`,
-                () => <any>null
+                () => null
             );
         }
 
@@ -644,7 +644,7 @@ namespace ts {
                 "cleanupSemanticCache()",
                 () => {
                     this.languageService.cleanupSemanticCache();
-                    return <any>null;
+                    return null;
                 });
         }
 
@@ -980,13 +980,13 @@ namespace ts {
             );
         }
 
-        public getEmitOutputObject(fileName: string): any {
+        public getEmitOutputObject(fileName: string): EmitOutput {
             return forwardCall(
                 this.logger,
                 `getEmitOutput('${fileName}')`,
                 /*returnJson*/ false,
                 () => this.languageService.getEmitOutput(fileName),
-                this.logPerformance);
+                this.logPerformance) as EmitOutput;
         }
     }
 
@@ -1030,7 +1030,7 @@ namespace ts {
             super(factory);
         }
 
-        private forwardJSONCall(actionDescription: string, action: () => any): any {
+        private forwardJSONCall(actionDescription: string, action: () => {}): string {
             return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance);
         }
 
@@ -1221,7 +1221,7 @@ namespace ts {
 
     // Here we expose the TypeScript services as an external module
     // so that it may be consumed easily like a node module.
-    declare const module: any;
+    declare const module: { exports: {} };
     if (typeof module !== "undefined" && module.exports) {
         module.exports = ts;
     }

src/services/symbolDisplay.ts

@@ -341,13 +341,19 @@ namespace ts.SymbolDisplay {
         }
         if (symbolFlags & SymbolFlags.Alias) {
             addNewLineIfDisplayPartsExist();
-            if (symbol.declarations[0].kind === SyntaxKind.NamespaceExportDeclaration) {
-                displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
-                displayParts.push(spacePart());
-                displayParts.push(keywordPart(SyntaxKind.NamespaceKeyword));
-            }
-            else {
-                displayParts.push(keywordPart(SyntaxKind.ImportKeyword));
+            switch (symbol.declarations[0].kind) {
+                case SyntaxKind.NamespaceExportDeclaration:
+                    displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                    displayParts.push(spacePart());
+                    displayParts.push(keywordPart(SyntaxKind.NamespaceKeyword));
+                    break;
+                case SyntaxKind.ExportAssignment:
+                    displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                    displayParts.push(spacePart());
+                    displayParts.push(keywordPart((symbol.declarations[0] as ExportAssignment).isExportEquals ? SyntaxKind.EqualsToken : SyntaxKind.DefaultKeyword));
+                    break;
+                default:
+                    displayParts.push(keywordPart(SyntaxKind.ImportKeyword));
             }
             displayParts.push(spacePart());
             addFullSymbolName(symbol);

tests/baselines/reference/abstractPropertyInConstructor.errors.txt

@@ -0,0 +1,37 @@
+tests/cases/compiler/abstractPropertyInConstructor.ts(4,24): error TS2715: Abstract property 'prop' in class 'AbstractClass' cannot be accessed in the constructor.
+tests/cases/compiler/abstractPropertyInConstructor.ts(7,18): error TS2715: Abstract property 'prop' in class 'AbstractClass' cannot be accessed in the constructor.
+tests/cases/compiler/abstractPropertyInConstructor.ts(9,14): error TS2715: Abstract property 'cb' in class 'AbstractClass' cannot be accessed in the constructor.
+
+
+==== tests/cases/compiler/abstractPropertyInConstructor.ts (3 errors) ====
+    abstract class AbstractClass {
+        constructor(str: string) {
+            this.method(parseInt(str));
+            let val = this.prop.toLowerCase();
+                           ~~~~
+!!! error TS2715: Abstract property 'prop' in class 'AbstractClass' cannot be accessed in the constructor.
+    
+            if (!str) {
+                this.prop = "Hello World";
+                     ~~~~
+!!! error TS2715: Abstract property 'prop' in class 'AbstractClass' cannot be accessed in the constructor.
+            }
+            this.cb(str);
+                 ~~
+!!! error TS2715: Abstract property 'cb' in class 'AbstractClass' cannot be accessed in the constructor.
+    
+            const innerFunction = () => {
+                return this.prop;
+            }
+        }
+    
+        abstract prop: string;
+        abstract cb: (s: string) => void;
+    
+        abstract method(num: number): void;
+    
+        method2() {
+            this.prop = this.prop + "!";
+        }
+    }
+    

tests/baselines/reference/abstractPropertyInConstructor.js

@@ -0,0 +1,46 @@
+//// [abstractPropertyInConstructor.ts]
+abstract class AbstractClass {
+    constructor(str: string) {
+        this.method(parseInt(str));
+        let val = this.prop.toLowerCase();
+
+        if (!str) {
+            this.prop = "Hello World";
+        }
+        this.cb(str);
+
+        const innerFunction = () => {
+            return this.prop;
+        }
+    }
+
+    abstract prop: string;
+    abstract cb: (s: string) => void;
+
+    abstract method(num: number): void;
+
+    method2() {
+        this.prop = this.prop + "!";
+    }
+}
+
+
+//// [abstractPropertyInConstructor.js]
+var AbstractClass = /** @class */ (function () {
+    function AbstractClass(str) {
+        var _this = this;
+        this.method(parseInt(str));
+        var val = this.prop.toLowerCase();
+        if (!str) {
+            this.prop = "Hello World";
+        }
+        this.cb(str);
+        var innerFunction = function () {
+            return _this.prop;
+        };
+    }
+    AbstractClass.prototype.method2 = function () {
+        this.prop = this.prop + "!";
+    };
+    return AbstractClass;
+}());

tests/baselines/reference/abstractPropertyInConstructor.symbols

@@ -0,0 +1,70 @@
+=== tests/cases/compiler/abstractPropertyInConstructor.ts ===
+abstract class AbstractClass {
+>AbstractClass : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+
+    constructor(str: string) {
+>str : Symbol(str, Decl(abstractPropertyInConstructor.ts, 1, 16))
+
+        this.method(parseInt(str));
+>this.method : Symbol(AbstractClass.method, Decl(abstractPropertyInConstructor.ts, 16, 37))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>method : Symbol(AbstractClass.method, Decl(abstractPropertyInConstructor.ts, 16, 37))
+>parseInt : Symbol(parseInt, Decl(lib.d.ts, --, --))
+>str : Symbol(str, Decl(abstractPropertyInConstructor.ts, 1, 16))
+
+        let val = this.prop.toLowerCase();
+>val : Symbol(val, Decl(abstractPropertyInConstructor.ts, 3, 11))
+>this.prop.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
+>this.prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
+
+        if (!str) {
+>str : Symbol(str, Decl(abstractPropertyInConstructor.ts, 1, 16))
+
+            this.prop = "Hello World";
+>this.prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+        }
+        this.cb(str);
+>this.cb : Symbol(AbstractClass.cb, Decl(abstractPropertyInConstructor.ts, 15, 26))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>cb : Symbol(AbstractClass.cb, Decl(abstractPropertyInConstructor.ts, 15, 26))
+>str : Symbol(str, Decl(abstractPropertyInConstructor.ts, 1, 16))
+
+        const innerFunction = () => {
+>innerFunction : Symbol(innerFunction, Decl(abstractPropertyInConstructor.ts, 10, 13))
+
+            return this.prop;
+>this.prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+        }
+    }
+
+    abstract prop: string;
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+
+    abstract cb: (s: string) => void;
+>cb : Symbol(AbstractClass.cb, Decl(abstractPropertyInConstructor.ts, 15, 26))
+>s : Symbol(s, Decl(abstractPropertyInConstructor.ts, 16, 18))
+
+    abstract method(num: number): void;
+>method : Symbol(AbstractClass.method, Decl(abstractPropertyInConstructor.ts, 16, 37))
+>num : Symbol(num, Decl(abstractPropertyInConstructor.ts, 18, 20))
+
+    method2() {
+>method2 : Symbol(AbstractClass.method2, Decl(abstractPropertyInConstructor.ts, 18, 39))
+
+        this.prop = this.prop + "!";
+>this.prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this.prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+>this : Symbol(AbstractClass, Decl(abstractPropertyInConstructor.ts, 0, 0))
+>prop : Symbol(AbstractClass.prop, Decl(abstractPropertyInConstructor.ts, 13, 5))
+    }
+}
+

tests/baselines/reference/abstractPropertyInConstructor.types

@@ -0,0 +1,81 @@
+=== tests/cases/compiler/abstractPropertyInConstructor.ts ===
+abstract class AbstractClass {
+>AbstractClass : AbstractClass
+
+    constructor(str: string) {
+>str : string
+
+        this.method(parseInt(str));
+>this.method(parseInt(str)) : void
+>this.method : (num: number) => void
+>this : this
+>method : (num: number) => void
+>parseInt(str) : number
+>parseInt : (s: string, radix?: number) => number
+>str : string
+
+        let val = this.prop.toLowerCase();
+>val : string
+>this.prop.toLowerCase() : string
+>this.prop.toLowerCase : () => string
+>this.prop : string
+>this : this
+>prop : string
+>toLowerCase : () => string
+
+        if (!str) {
+>!str : boolean
+>str : string
+
+            this.prop = "Hello World";
+>this.prop = "Hello World" : "Hello World"
+>this.prop : string
+>this : this
+>prop : string
+>"Hello World" : "Hello World"
+        }
+        this.cb(str);
+>this.cb(str) : void
+>this.cb : (s: string) => void
+>this : this
+>cb : (s: string) => void
+>str : string
+
+        const innerFunction = () => {
+>innerFunction : () => string
+>() => {            return this.prop;        } : () => string
+
+            return this.prop;
+>this.prop : string
+>this : this
+>prop : string
+        }
+    }
+
+    abstract prop: string;
+>prop : string
+
+    abstract cb: (s: string) => void;
+>cb : (s: string) => void
+>s : string
+
+    abstract method(num: number): void;
+>method : (num: number) => void
+>num : number
+
+    method2() {
+>method2 : () => void
+
+        this.prop = this.prop + "!";
+>this.prop = this.prop + "!" : string
+>this.prop : string
+>this : this
+>prop : string
+>this.prop + "!" : string
+>this.prop : string
+>this : this
+>prop : string
+>"!" : "!"
+    }
+}
+

tests/baselines/reference/anyInferenceAnonymousFunctions.symbols

@@ -3,9 +3,9 @@ var paired: any[];
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 
 paired.reduce(function (a1, a2) {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
 >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27))
 
@@ -15,9 +15,9 @@ paired.reduce(function (a1, a2) {
 } , []);
 
 paired.reduce((b1, b2) => {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
 >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18))
 
@@ -27,9 +27,9 @@ paired.reduce((b1, b2) => {
 } , []);
 
 paired.reduce((b3, b4) => b3.concat({}), []);
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))

tests/baselines/reference/anyInferenceAnonymousFunctions.types

@@ -4,9 +4,9 @@ var paired: any[];
 
 paired.reduce(function (a1, a2) {
 >paired.reduce(function (a1, a2) {    return a1.concat({});} , []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >function (a1, a2) {    return a1.concat({});} : (a1: any, a2: any) => any
 >a1 : any
 >a2 : any
@@ -23,9 +23,9 @@ paired.reduce(function (a1, a2) {
 
 paired.reduce((b1, b2) => {
 >paired.reduce((b1, b2) => {    return b1.concat({});} , []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >(b1, b2) => {    return b1.concat({});} : (b1: any, b2: any) => any
 >b1 : any
 >b2 : any
@@ -42,9 +42,9 @@ paired.reduce((b1, b2) => {
 
 paired.reduce((b3, b4) => b3.concat({}), []);
 >paired.reduce((b3, b4) => b3.concat({}), []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
 >b3 : any
 >b4 : any

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -1442,6 +1442,10 @@ declare namespace ts {
     interface JSDocUnknownTag extends JSDocTag {
         kind: SyntaxKind.JSDocTag;
     }
+    /**
+     * Note that `@extends` is a synonym of `@augments`.
+     * Both tags are represented by this interface.
+     */
     interface JSDocAugmentsTag extends JSDocTag {
         kind: SyntaxKind.JSDocAugmentsTag;
         class: ExpressionWithTypeArguments & {
@@ -1473,7 +1477,7 @@ declare namespace ts {
     interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
         parent: JSDoc;
         name: EntityName;
-        typeExpression: JSDocTypeExpression;
+        typeExpression?: JSDocTypeExpression;
         /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
         isNameFirst: boolean;
         isBracketed: boolean;
@@ -1727,6 +1731,10 @@ declare namespace ts {
         signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        /**
+         * @deprecated Use the createX factory functions or XToY typechecker methods and `createPrinter` or the `xToString` methods instead
+         * This will be removed in a future version.
+         */
         getSymbolDisplayBuilder(): SymbolDisplayBuilder;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];
@@ -2866,6 +2874,8 @@ declare namespace ts {
     function getJSDocReturnType(node: Node): TypeNode | undefined;
     /** Get all JSDoc tags related to a node, including those on parent nodes. */
     function getJSDocTags(node: Node): ReadonlyArray<JSDocTag> | undefined;
+    /** Gets all JSDoc tags of a specified kind, or undefined if not present. */
+    function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): ReadonlyArray<JSDocTag> | undefined;
 }
 declare namespace ts {
     function isNumericLiteral(node: Node): node is NumericLiteral;
@@ -7104,7 +7114,7 @@ declare namespace ts.server {
         getScriptKind(fileName: string): ScriptKind;
         getScriptVersion(filename: string): string;
         getScriptSnapshot(filename: string): IScriptSnapshot;
-        getCancellationToken(): ThrottledCancellationToken;
+        getCancellationToken(): HostCancellationToken;
         getCurrentDirectory(): string;
         getDefaultLibFileName(): string;
         useCaseSensitiveFileNames(): boolean;
@@ -7131,7 +7141,6 @@ declare namespace ts.server {
         enableLanguageService(): void;
         disableLanguageService(): void;
         getProjectName(): string;
-        abstract getProjectRootPath(): string | undefined;
         abstract getTypeAcquisition(): TypeAcquisition;
         getExternalFiles(): SortedReadonlyArray<string>;
         getSourceFile(path: Path): SourceFile;
@@ -7184,7 +7193,6 @@ declare namespace ts.server {
         addRoot(info: ScriptInfo): void;
         removeRoot(info: ScriptInfo): void;
         isProjectWithSingleRoot(): boolean;
-        getProjectRootPath(): string;
         close(): void;
         getTypeAcquisition(): TypeAcquisition;
     }
@@ -7211,7 +7219,6 @@ declare namespace ts.server {
         enablePlugins(): void;
         private enablePlugin(pluginConfigEntry, searchPaths);
         private enableProxy(pluginModuleFactory, configEntry);
-        getProjectRootPath(): string;
         /**
          * Get the errors that dont have any file name associated
          */
@@ -7237,11 +7244,9 @@ declare namespace ts.server {
     class ExternalProject extends Project {
         externalProjectName: string;
         compileOnSaveEnabled: boolean;
-        private readonly projectFilePath;
         excludedFiles: ReadonlyArray<NormalizedPath>;
         private typeAcquisition;
         getExcludedFiles(): ReadonlyArray<NormalizedPath>;
-        getProjectRootPath(): string;
         getTypeAcquisition(): TypeAcquisition;
         setTypeAcquisition(newTypeAcquisition: TypeAcquisition): void;
     }
@@ -7520,7 +7525,7 @@ declare namespace ts.server {
         private sendConfigFileDiagEvent(project, triggerFile);
         private getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath);
         private getOrCreateSingleInferredProjectIfEnabled();
-        private createInferredProject(rootDirectoryForResolution, isSingleInferredProject?, projectRootPath?);
+        private createInferredProject(currentDirectory, isSingleInferredProject?, projectRootPath?);
         getScriptInfo(uncheckedFileName: string): ScriptInfo;
         private watchClosedScriptInfo(info);
         private stopWatchingScriptInfo(info);

tests/baselines/reference/api/typescript.d.ts

@@ -1442,6 +1442,10 @@ declare namespace ts {
     interface JSDocUnknownTag extends JSDocTag {
         kind: SyntaxKind.JSDocTag;
     }
+    /**
+     * Note that `@extends` is a synonym of `@augments`.
+     * Both tags are represented by this interface.
+     */
     interface JSDocAugmentsTag extends JSDocTag {
         kind: SyntaxKind.JSDocAugmentsTag;
         class: ExpressionWithTypeArguments & {
@@ -1473,7 +1477,7 @@ declare namespace ts {
     interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
         parent: JSDoc;
         name: EntityName;
-        typeExpression: JSDocTypeExpression;
+        typeExpression?: JSDocTypeExpression;
         /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
         isNameFirst: boolean;
         isBracketed: boolean;
@@ -1727,6 +1731,10 @@ declare namespace ts {
         signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        /**
+         * @deprecated Use the createX factory functions or XToY typechecker methods and `createPrinter` or the `xToString` methods instead
+         * This will be removed in a future version.
+         */
         getSymbolDisplayBuilder(): SymbolDisplayBuilder;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];
@@ -2921,6 +2929,8 @@ declare namespace ts {
     function getJSDocReturnType(node: Node): TypeNode | undefined;
     /** Get all JSDoc tags related to a node, including those on parent nodes. */
     function getJSDocTags(node: Node): ReadonlyArray<JSDocTag> | undefined;
+    /** Gets all JSDoc tags of a specified kind, or undefined if not present. */
+    function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): ReadonlyArray<JSDocTag> | undefined;
 }
 declare namespace ts {
     function isNumericLiteral(node: Node): node is NumericLiteral;

tests/baselines/reference/arrayFind.js

@@ -0,0 +1,22 @@
+//// [arrayFind.ts]
+// test fix for #18112, type guard predicates should narrow returned element
+function isNumber(x: any): x is number {
+  return typeof x === "number";
+}
+
+const arrayOfStringsNumbersAndBooleans = ["string", false, 0, "strung", 1, true];
+const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(isNumber);
+
+const readonlyArrayOfStringsNumbersAndBooleans = arrayOfStringsNumbersAndBooleans as ReadonlyArray<string | number | boolean>;
+const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAndBooleans.find(isNumber);
+
+
+//// [arrayFind.js]
+// test fix for #18112, type guard predicates should narrow returned element
+function isNumber(x) {
+    return typeof x === "number";
+}
+var arrayOfStringsNumbersAndBooleans = ["string", false, 0, "strung", 1, true];
+var foundNumber = arrayOfStringsNumbersAndBooleans.find(isNumber);
+var readonlyArrayOfStringsNumbersAndBooleans = arrayOfStringsNumbersAndBooleans;
+var readonlyFoundNumber = readonlyArrayOfStringsNumbersAndBooleans.find(isNumber);

tests/baselines/reference/arrayFind.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/arrayFind.ts ===
+// test fix for #18112, type guard predicates should narrow returned element
+function isNumber(x: any): x is number {
+>isNumber : Symbol(isNumber, Decl(arrayFind.ts, 0, 0))
+>x : Symbol(x, Decl(arrayFind.ts, 1, 18))
+>x : Symbol(x, Decl(arrayFind.ts, 1, 18))
+
+  return typeof x === "number";
+>x : Symbol(x, Decl(arrayFind.ts, 1, 18))
+}
+
+const arrayOfStringsNumbersAndBooleans = ["string", false, 0, "strung", 1, true];
+>arrayOfStringsNumbersAndBooleans : Symbol(arrayOfStringsNumbersAndBooleans, Decl(arrayFind.ts, 5, 5))
+
+const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(isNumber);
+>foundNumber : Symbol(foundNumber, Decl(arrayFind.ts, 6, 5))
+>arrayOfStringsNumbersAndBooleans.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>arrayOfStringsNumbersAndBooleans : Symbol(arrayOfStringsNumbersAndBooleans, Decl(arrayFind.ts, 5, 5))
+>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>isNumber : Symbol(isNumber, Decl(arrayFind.ts, 0, 0))
+
+const readonlyArrayOfStringsNumbersAndBooleans = arrayOfStringsNumbersAndBooleans as ReadonlyArray<string | number | boolean>;
+>readonlyArrayOfStringsNumbersAndBooleans : Symbol(readonlyArrayOfStringsNumbersAndBooleans, Decl(arrayFind.ts, 8, 5))
+>arrayOfStringsNumbersAndBooleans : Symbol(arrayOfStringsNumbersAndBooleans, Decl(arrayFind.ts, 5, 5))
+>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+
+const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAndBooleans.find(isNumber);
+>readonlyFoundNumber : Symbol(readonlyFoundNumber, Decl(arrayFind.ts, 9, 5))
+>readonlyArrayOfStringsNumbersAndBooleans.find : Symbol(ReadonlyArray.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>readonlyArrayOfStringsNumbersAndBooleans : Symbol(readonlyArrayOfStringsNumbersAndBooleans, Decl(arrayFind.ts, 8, 5))
+>find : Symbol(ReadonlyArray.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>isNumber : Symbol(isNumber, Decl(arrayFind.ts, 0, 0))
+

tests/baselines/reference/arrayFind.types

@@ -0,0 +1,46 @@
+=== tests/cases/compiler/arrayFind.ts ===
+// test fix for #18112, type guard predicates should narrow returned element
+function isNumber(x: any): x is number {
+>isNumber : (x: any) => x is number
+>x : any
+>x : any
+
+  return typeof x === "number";
+>typeof x === "number" : boolean
+>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : any
+>"number" : "number"
+}
+
+const arrayOfStringsNumbersAndBooleans = ["string", false, 0, "strung", 1, true];
+>arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
+>["string", false, 0, "strung", 1, true] : (string | number | boolean)[]
+>"string" : "string"
+>false : false
+>0 : 0
+>"strung" : "strung"
+>1 : 1
+>true : true
+
+const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(isNumber);
+>foundNumber : number
+>arrayOfStringsNumbersAndBooleans.find(isNumber) : number
+>arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (this: void, value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => boolean, thisArg?: any): string | number | boolean; }
+>arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
+>find : { <S extends string | number | boolean>(predicate: (this: void, value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => boolean, thisArg?: any): string | number | boolean; }
+>isNumber : (x: any) => x is number
+
+const readonlyArrayOfStringsNumbersAndBooleans = arrayOfStringsNumbersAndBooleans as ReadonlyArray<string | number | boolean>;
+>readonlyArrayOfStringsNumbersAndBooleans : ReadonlyArray<string | number | boolean>
+>arrayOfStringsNumbersAndBooleans as ReadonlyArray<string | number | boolean> : ReadonlyArray<string | number | boolean>
+>arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
+>ReadonlyArray : ReadonlyArray<T>
+
+const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAndBooleans.find(isNumber);
+>readonlyFoundNumber : number
+>readonlyArrayOfStringsNumbersAndBooleans.find(isNumber) : number
+>readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (this: void, value: string | number | boolean, index: number, obj: ReadonlyArray<string | number | boolean>) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: ReadonlyArray<string | number | boolean>) => boolean, thisArg?: any): string | number | boolean; }
+>readonlyArrayOfStringsNumbersAndBooleans : ReadonlyArray<string | number | boolean>
+>find : { <S extends string | number | boolean>(predicate: (this: void, value: string | number | boolean, index: number, obj: ReadonlyArray<string | number | boolean>) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: ReadonlyArray<string | number | boolean>) => boolean, thisArg?: any): string | number | boolean; }
+>isNumber : (x: any) => x is number
+

tests/baselines/reference/decoratorOnClassMethod6.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1241: Unable to resolve signature of method decorator when called as an expression.
+tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5): error TS1329: 'dec' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@dec()'?
 
 
 ==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts (1 errors) ====
@@ -7,5 +7,5 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod6.ts(4,5):
     class C {
         @dec ["method"]() {}
         ~~~~
-!!! error TS1241: Unable to resolve signature of method decorator when called as an expression.
+!!! error TS1329: 'dec' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@dec()'?
     }

tests/baselines/reference/decoratorOnClassProperty11.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1240: Unable to resolve signature of property decorator when called as an expression.
+tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(4,5): error TS1329: 'dec' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@dec()'?
 
 
 ==== tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts (1 errors) ====
@@ -7,5 +7,5 @@ tests/cases/conformance/decorators/class/property/decoratorOnClassProperty11.ts(
     class C {
         @dec prop;
         ~~~~
-!!! error TS1240: Unable to resolve signature of property decorator when called as an expression.
+!!! error TS1329: 'dec' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@dec()'?
     }

tests/baselines/reference/discriminatedUnionErrorMessage.errors.txt

@@ -1,6 +1,5 @@
-tests/cases/compiler/discriminatedUnionErrorMessage.ts(8,5): error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
-  Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Square'.
-    Property 'size' is missing in type '{ kind: "sq"; x: number; y: number; }'.
+tests/cases/compiler/discriminatedUnionErrorMessage.ts(10,5): error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
+  Object literal may only specify known properties, and 'x' does not exist in type 'Square'.
 
 
 ==== tests/cases/compiler/discriminatedUnionErrorMessage.ts (1 errors) ====
@@ -12,12 +11,11 @@ tests/cases/compiler/discriminatedUnionErrorMessage.ts(8,5): error TS2322: Type
         | Rectangle
         | Circle;
     let shape: Shape = {
-        ~~~~~
-!!! error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
-!!! error TS2322:   Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Square'.
-!!! error TS2322:     Property 'size' is missing in type '{ kind: "sq"; x: number; y: number; }'.
         kind: "sq",
         x: 12,
+        ~~~~~
+!!! error TS2322: Type '{ kind: "sq"; x: number; y: number; }' is not assignable to type 'Shape'.
+!!! error TS2322:   Object literal may only specify known properties, and 'x' does not exist in type 'Square'.
         y: 13,
     }
     

tests/baselines/reference/duplicateExportAssignments.errors.txt

@@ -1,34 +1,34 @@
-tests/cases/conformance/externalModules/foo1.ts(3,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo1.ts(4,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo2.ts(3,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo2.ts(4,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo3.ts(7,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo3.ts(8,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo4.ts(1,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo4.ts(8,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo5.ts(4,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo5.ts(5,1): error TS2300: Duplicate identifier 'export='.
-tests/cases/conformance/externalModules/foo5.ts(6,1): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo1.ts(3,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo1.ts(4,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo2.ts(3,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo2.ts(4,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo3.ts(7,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo3.ts(8,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo4.ts(1,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo4.ts(8,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo5.ts(4,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo5.ts(5,10): error TS2300: Duplicate identifier 'export='.
+tests/cases/conformance/externalModules/foo5.ts(6,10): error TS2300: Duplicate identifier 'export='.
 
 
 ==== tests/cases/conformance/externalModules/foo1.ts (2 errors) ====
     var x = 10;
     var y = 20;
     export = x;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     export = y;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     
 ==== tests/cases/conformance/externalModules/foo2.ts (2 errors) ====
     var x = 10;
     class y {};
     export = x;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     export = y;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     
 ==== tests/cases/conformance/externalModules/foo3.ts (2 errors) ====
@@ -39,15 +39,15 @@ tests/cases/conformance/externalModules/foo5.ts(6,1): error TS2300: Duplicate id
     	y: number;
     }
     export = x;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     export = y;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     
 ==== tests/cases/conformance/externalModules/foo4.ts (2 errors) ====
     export = x;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     function x(){
     	return 42;
@@ -56,7 +56,7 @@ tests/cases/conformance/externalModules/foo5.ts(6,1): error TS2300: Duplicate id
     	return 42;
     }
     export = y;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     
 ==== tests/cases/conformance/externalModules/foo5.ts (3 errors) ====
@@ -64,12 +64,12 @@ tests/cases/conformance/externalModules/foo5.ts(6,1): error TS2300: Duplicate id
     var y = "test";
     var z = {};
     export = x;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     export = y;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     export = z;
-    ~~~~~~~~~~~
+             ~
 !!! error TS2300: Duplicate identifier 'export='.
     

tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols

@@ -4,7 +4,7 @@ interface Array<T> {
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T,
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 11))
 >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 24))
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
@@ -21,7 +21,7 @@ interface Array<T> {
 >T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11))
 >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 14))
 >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 27))
@@ -44,9 +44,9 @@ var a: Array<string>;
 
 var r5 = a.reduce((x, y) => x + y);
 >r5 : Symbol(r5, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 3))
->a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
 >y : Symbol(y, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 21))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))

tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types

@@ -4,7 +4,7 @@ interface Array<T> {
 >T : T
 
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T,
->reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
 >previousValue : T
 >T : T
@@ -21,7 +21,7 @@ interface Array<T> {
 >T : T
 
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
->reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >U : U
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
 >previousValue : U
@@ -45,9 +45,9 @@ var a: Array<string>;
 var r5 = a.reduce((x, y) => x + y);
 >r5 : string
 >a.reduce((x, y) => x + y) : string
->a.reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>a.reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
 >a : string[]
->reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
 >(x, y) => x + y : (x: string, y: string) => string
 >x : string
 >y : string

tests/baselines/reference/dynamicImportInDefaultExportExpression.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/dynamicImportInDefaultExportExpression.ts(3,23): error TS2307: Cannot find module './foo2'.
+
+
+==== tests/cases/compiler/dynamicImportInDefaultExportExpression.ts (1 errors) ====
+    export default {
+        getInstance: function () {
+            return import('./foo2');
+                          ~~~~~~~~
+!!! error TS2307: Cannot find module './foo2'.
+        }
+    }

tests/baselines/reference/dynamicImportInDefaultExportExpression.js

@@ -0,0 +1,15 @@
+//// [dynamicImportInDefaultExportExpression.ts]
+export default {
+    getInstance: function () {
+        return import('./foo2');
+    }
+}
+
+//// [dynamicImportInDefaultExportExpression.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = {
+    getInstance: function () {
+        return Promise.resolve().then(function () { return require('./foo2'); });
+    }
+};

tests/baselines/reference/dynamicImportInDefaultExportExpression.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/dynamicImportInDefaultExportExpression.ts ===
+export default {
+    getInstance: function () {
+>getInstance : Symbol(getInstance, Decl(dynamicImportInDefaultExportExpression.ts, 0, 16))
+
+        return import('./foo2');
+    }
+}

tests/baselines/reference/dynamicImportInDefaultExportExpression.types

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/dynamicImportInDefaultExportExpression.ts ===
+export default {
+>{    getInstance: function () {        return import('./foo2');    }} : { getInstance: () => Promise<any>; }
+
+    getInstance: function () {
+>getInstance : () => Promise<any>
+>function () {        return import('./foo2');    } : () => Promise<any>
+
+        return import('./foo2');
+>import('./foo2') : Promise<any>
+>'./foo2' : "./foo2"
+    }
+}

tests/baselines/reference/dynamicImportWithNestedThis_es2015.js

@@ -0,0 +1,37 @@
+//// [dynamicImportWithNestedThis_es2015.ts]
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+	private _path = './other';
+
+	dynamic() {
+		return import(this._path);
+	}
+}
+
+const c = new C();
+c.dynamic();
+
+//// [dynamicImportWithNestedThis_es2015.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    // https://github.com/Microsoft/TypeScript/issues/17564
+    class C {
+        constructor() {
+            this._path = './other';
+        }
+        dynamic() {
+            return __syncRequire ? Promise.resolve().then(() => require(this._path)) : new Promise((resolve_1, reject_1) => { require([this._path], resolve_1, reject_1); });
+        }
+    }
+    const c = new C();
+    c.dynamic();
+});

tests/baselines/reference/dynamicImportWithNestedThis_es2015.symbols

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/dynamicImportWithNestedThis_es2015.ts ===
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+>C : Symbol(C, Decl(dynamicImportWithNestedThis_es2015.ts, 0, 0))
+
+	private _path = './other';
+>_path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es2015.ts, 1, 9))
+
+	dynamic() {
+>dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es2015.ts, 2, 27))
+
+		return import(this._path);
+>this._path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es2015.ts, 1, 9))
+>this : Symbol(C, Decl(dynamicImportWithNestedThis_es2015.ts, 0, 0))
+>_path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es2015.ts, 1, 9))
+	}
+}
+
+const c = new C();
+>c : Symbol(c, Decl(dynamicImportWithNestedThis_es2015.ts, 9, 5))
+>C : Symbol(C, Decl(dynamicImportWithNestedThis_es2015.ts, 0, 0))
+
+c.dynamic();
+>c.dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es2015.ts, 2, 27))
+>c : Symbol(c, Decl(dynamicImportWithNestedThis_es2015.ts, 9, 5))
+>dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es2015.ts, 2, 27))
+

tests/baselines/reference/dynamicImportWithNestedThis_es2015.types

@@ -0,0 +1,31 @@
+=== tests/cases/compiler/dynamicImportWithNestedThis_es2015.ts ===
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+>C : C
+
+	private _path = './other';
+>_path : string
+>'./other' : "./other"
+
+	dynamic() {
+>dynamic : () => Promise<any>
+
+		return import(this._path);
+>import(this._path) : Promise<any>
+>this._path : string
+>this : this
+>_path : string
+	}
+}
+
+const c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+c.dynamic();
+>c.dynamic() : Promise<any>
+>c.dynamic : () => Promise<any>
+>c : C
+>dynamic : () => Promise<any>
+

tests/baselines/reference/dynamicImportWithNestedThis_es5.js

@@ -0,0 +1,39 @@
+//// [dynamicImportWithNestedThis_es5.ts]
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+	private _path = './other';
+
+	dynamic() {
+		return import(this._path);
+	}
+}
+
+const c = new C();
+c.dynamic();
+
+//// [dynamicImportWithNestedThis_es5.js]
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    // https://github.com/Microsoft/TypeScript/issues/17564
+    var C = /** @class */ (function () {
+        function C() {
+            this._path = './other';
+        }
+        C.prototype.dynamic = function () {
+            var _this = this;
+            return __syncRequire ? Promise.resolve().then(function () { return require(_this._path); }) : new Promise(function (resolve_1, reject_1) { require([_this._path], resolve_1, reject_1); });
+        };
+        return C;
+    }());
+    var c = new C();
+    c.dynamic();
+});

tests/baselines/reference/dynamicImportWithNestedThis_es5.symbols

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/dynamicImportWithNestedThis_es5.ts ===
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+>C : Symbol(C, Decl(dynamicImportWithNestedThis_es5.ts, 0, 0))
+
+	private _path = './other';
+>_path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es5.ts, 1, 9))
+
+	dynamic() {
+>dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es5.ts, 2, 27))
+
+		return import(this._path);
+>this._path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es5.ts, 1, 9))
+>this : Symbol(C, Decl(dynamicImportWithNestedThis_es5.ts, 0, 0))
+>_path : Symbol(C._path, Decl(dynamicImportWithNestedThis_es5.ts, 1, 9))
+	}
+}
+
+const c = new C();
+>c : Symbol(c, Decl(dynamicImportWithNestedThis_es5.ts, 9, 5))
+>C : Symbol(C, Decl(dynamicImportWithNestedThis_es5.ts, 0, 0))
+
+c.dynamic();
+>c.dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es5.ts, 2, 27))
+>c : Symbol(c, Decl(dynamicImportWithNestedThis_es5.ts, 9, 5))
+>dynamic : Symbol(C.dynamic, Decl(dynamicImportWithNestedThis_es5.ts, 2, 27))
+

tests/baselines/reference/dynamicImportWithNestedThis_es5.types

@@ -0,0 +1,31 @@
+=== tests/cases/compiler/dynamicImportWithNestedThis_es5.ts ===
+// https://github.com/Microsoft/TypeScript/issues/17564
+class C {
+>C : C
+
+	private _path = './other';
+>_path : string
+>'./other' : "./other"
+
+	dynamic() {
+>dynamic : () => Promise<any>
+
+		return import(this._path);
+>import(this._path) : Promise<any>
+>this._path : string
+>this : this
+>_path : string
+	}
+}
+
+const c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+c.dynamic();
+>c.dynamic() : Promise<any>
+>c.dynamic : () => Promise<any>
+>c : C
+>dynamic : () => Promise<any>
+

tests/baselines/reference/es5-commonjs7.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/test.d.ts ===
 export default undefined;
->undefined : Symbol(default)
+>undefined : Symbol(undefined)
 
 export var __esModule;
 >__esModule : Symbol(__esModule, Decl(test.d.ts, 1, 10))

tests/baselines/reference/excessPropertyCheckWithUnions.errors.txt

@@ -0,0 +1,99 @@
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(10,30): error TS2322: Type '{ tag: "T"; a1: string; }' is not assignable to type 'ADT'.
+  Object literal may only specify known properties, and 'a1' does not exist in type '{ tag: "T"; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(11,21): error TS2322: Type '{ tag: "A"; d20: 12; }' is not assignable to type 'ADT'.
+  Object literal may only specify known properties, and 'd20' does not exist in type '{ tag: "A"; a1: string; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(12,1): error TS2322: Type '{ tag: "D"; }' is not assignable to type 'ADT'.
+  Type '{ tag: "D"; }' is not assignable to type '{ tag: "D"; d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; }'.
+    Property 'd20' is missing in type '{ tag: "D"; }'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(33,28): error TS2322: Type '{ tag: "A"; x: string; extra: number; }' is not assignable to type 'Ambiguous'.
+  Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(34,26): error TS2322: Type '{ tag: "A"; y: number; extra: number; }' is not assignable to type 'Ambiguous'.
+  Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(39,1): error TS2322: Type '{ tag: "A"; }' is not assignable to type 'Ambiguous'.
+  Type '{ tag: "A"; }' is not assignable to type '{ tag: "C"; }'.
+    Types of property 'tag' are incompatible.
+      Type '"A"' is not assignable to type '"C"'.
+tests/cases/compiler/excessPropertyCheckWithUnions.ts(40,1): error TS2322: Type '{ tag: "A"; z: true; }' is not assignable to type 'Ambiguous'.
+  Type '{ tag: "A"; z: true; }' is not assignable to type '{ tag: "C"; }'.
+    Types of property 'tag' are incompatible.
+      Type '"A"' is not assignable to type '"C"'.
+
+
+==== tests/cases/compiler/excessPropertyCheckWithUnions.ts (7 errors) ====
+    type ADT = {
+        tag: "A",
+        a1: string
+    } | {
+        tag: "D",
+        d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+    } | {
+        tag: "T",
+    }
+    let wrong: ADT = { tag: "T", a1: "extra" }
+                                 ~~~~~~~~~~~
+!!! error TS2322: Type '{ tag: "T"; a1: string; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Object literal may only specify known properties, and 'a1' does not exist in type '{ tag: "T"; }'.
+    wrong = { tag: "A", d20: 12 }
+                        ~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; d20: 12; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Object literal may only specify known properties, and 'd20' does not exist in type '{ tag: "A"; a1: string; }'.
+    wrong = { tag: "D" }
+    ~~~~~
+!!! error TS2322: Type '{ tag: "D"; }' is not assignable to type 'ADT'.
+!!! error TS2322:   Type '{ tag: "D"; }' is not assignable to type '{ tag: "D"; d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; }'.
+!!! error TS2322:     Property 'd20' is missing in type '{ tag: "D"; }'.
+    
+    type Ambiguous = {
+        tag: "A",
+        x: string
+    } | {
+        tag: "A",
+        y: number
+    } | {
+        tag: "B",
+        z: boolean
+    } | {
+        tag: "C"
+    }
+    let amb: Ambiguous
+    // no error for ambiguous tag, even when it could satisfy both constituents at once
+    amb = { tag: "A", x: "hi" }
+    amb = { tag: "A", y: 12 }
+    amb = { tag: "A", x: "hi", y: 12 }
+    
+    // correctly error on excess property 'extra', even when ambiguous
+    amb = { tag: "A", x: "hi", extra: 12 }
+                               ~~~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; x: string; extra: number; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+    amb = { tag: "A", y: 12, extra: 12 }
+                             ~~~~~~~~~
+!!! error TS2322: Type '{ tag: "A"; y: number; extra: number; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Object literal may only specify known properties, and 'extra' does not exist in type 'Ambiguous'.
+    
+    // assignability errors still work.
+    // But note that the error for `z: true` is the fallback one of reporting on
+    // the last constituent since assignability error reporting can't find a single best discriminant either.
+    amb = { tag: "A" }
+    ~~~
+!!! error TS2322: Type '{ tag: "A"; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Type '{ tag: "A"; }' is not assignable to type '{ tag: "C"; }'.
+!!! error TS2322:     Types of property 'tag' are incompatible.
+!!! error TS2322:       Type '"A"' is not assignable to type '"C"'.
+    amb = { tag: "A", z: true }
+    ~~~
+!!! error TS2322: Type '{ tag: "A"; z: true; }' is not assignable to type 'Ambiguous'.
+!!! error TS2322:   Type '{ tag: "A"; z: true; }' is not assignable to type '{ tag: "C"; }'.
+!!! error TS2322:     Types of property 'tag' are incompatible.
+!!! error TS2322:       Type '"A"' is not assignable to type '"C"'.
+    
+    type Overlapping =
+        | { a: 1, b: 1, first: string }
+        | { a: 2, second: string }
+        | { b: 3, third: string }
+    let over: Overlapping
+    
+    // these two are not reported because there are two discriminant properties
+    over = { a: 1, b: 1, first: "ok", second: "error" }
+    over = { a: 1, b: 1, first: "ok", third: "error" }
+    

tests/baselines/reference/excessPropertyCheckWithUnions.js

@@ -0,0 +1,74 @@
+//// [excessPropertyCheckWithUnions.ts]
+type ADT = {
+    tag: "A",
+    a1: string
+} | {
+    tag: "D",
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+} | {
+    tag: "T",
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+wrong = { tag: "A", d20: 12 }
+wrong = { tag: "D" }
+
+type Ambiguous = {
+    tag: "A",
+    x: string
+} | {
+    tag: "A",
+    y: number
+} | {
+    tag: "B",
+    z: boolean
+} | {
+    tag: "C"
+}
+let amb: Ambiguous
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+amb = { tag: "A", y: 12 }
+amb = { tag: "A", x: "hi", y: 12 }
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+amb = { tag: "A", y: 12, extra: 12 }
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+amb = { tag: "A", z: true }
+
+type Overlapping =
+    | { a: 1, b: 1, first: string }
+    | { a: 2, second: string }
+    | { b: 3, third: string }
+let over: Overlapping
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+over = { a: 1, b: 1, first: "ok", third: "error" }
+
+
+//// [excessPropertyCheckWithUnions.js]
+var wrong = { tag: "T", a1: "extra" };
+wrong = { tag: "A", d20: 12 };
+wrong = { tag: "D" };
+var amb;
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" };
+amb = { tag: "A", y: 12 };
+amb = { tag: "A", x: "hi", y: 12 };
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 };
+amb = { tag: "A", y: 12, extra: 12 };
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" };
+amb = { tag: "A", z: true };
+var over;
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" };
+over = { a: 1, b: 1, first: "ok", third: "error" };

tests/baselines/reference/excessPropertyCheckWithUnions.symbols

@@ -0,0 +1,144 @@
+=== tests/cases/compiler/excessPropertyCheckWithUnions.ts ===
+type ADT = {
+>ADT : Symbol(ADT, Decl(excessPropertyCheckWithUnions.ts, 0, 0))
+
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 0, 12))
+
+    a1: string
+>a1 : Symbol(a1, Decl(excessPropertyCheckWithUnions.ts, 1, 13))
+
+} | {
+    tag: "D",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 3, 5))
+
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+>d20 : Symbol(d20, Decl(excessPropertyCheckWithUnions.ts, 4, 13))
+
+} | {
+    tag: "T",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 6, 5))
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>ADT : Symbol(ADT, Decl(excessPropertyCheckWithUnions.ts, 0, 0))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 9, 18))
+>a1 : Symbol(a1, Decl(excessPropertyCheckWithUnions.ts, 9, 28))
+
+wrong = { tag: "A", d20: 12 }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 10, 9))
+>d20 : Symbol(d20, Decl(excessPropertyCheckWithUnions.ts, 10, 19))
+
+wrong = { tag: "D" }
+>wrong : Symbol(wrong, Decl(excessPropertyCheckWithUnions.ts, 9, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 11, 9))
+
+type Ambiguous = {
+>Ambiguous : Symbol(Ambiguous, Decl(excessPropertyCheckWithUnions.ts, 11, 20))
+
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 13, 18))
+
+    x: string
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 14, 13))
+
+} | {
+    tag: "A",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 16, 5))
+
+    y: number
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 17, 13))
+
+} | {
+    tag: "B",
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 19, 5))
+
+    z: boolean
+>z : Symbol(z, Decl(excessPropertyCheckWithUnions.ts, 20, 13))
+
+} | {
+    tag: "C"
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 22, 5))
+}
+let amb: Ambiguous
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>Ambiguous : Symbol(Ambiguous, Decl(excessPropertyCheckWithUnions.ts, 11, 20))
+
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 27, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 27, 17))
+
+amb = { tag: "A", y: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 28, 7))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 28, 17))
+
+amb = { tag: "A", x: "hi", y: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 29, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 29, 17))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 29, 26))
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 32, 7))
+>x : Symbol(x, Decl(excessPropertyCheckWithUnions.ts, 32, 17))
+>extra : Symbol(extra, Decl(excessPropertyCheckWithUnions.ts, 32, 26))
+
+amb = { tag: "A", y: 12, extra: 12 }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 33, 7))
+>y : Symbol(y, Decl(excessPropertyCheckWithUnions.ts, 33, 17))
+>extra : Symbol(extra, Decl(excessPropertyCheckWithUnions.ts, 33, 24))
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 38, 7))
+
+amb = { tag: "A", z: true }
+>amb : Symbol(amb, Decl(excessPropertyCheckWithUnions.ts, 25, 3))
+>tag : Symbol(tag, Decl(excessPropertyCheckWithUnions.ts, 39, 7))
+>z : Symbol(z, Decl(excessPropertyCheckWithUnions.ts, 39, 17))
+
+type Overlapping =
+>Overlapping : Symbol(Overlapping, Decl(excessPropertyCheckWithUnions.ts, 39, 27))
+
+    | { a: 1, b: 1, first: string }
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 42, 7))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 42, 13))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 42, 19))
+
+    | { a: 2, second: string }
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 43, 7))
+>second : Symbol(second, Decl(excessPropertyCheckWithUnions.ts, 43, 13))
+
+    | { b: 3, third: string }
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 44, 7))
+>third : Symbol(third, Decl(excessPropertyCheckWithUnions.ts, 44, 13))
+
+let over: Overlapping
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>Overlapping : Symbol(Overlapping, Decl(excessPropertyCheckWithUnions.ts, 39, 27))
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 48, 8))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 48, 14))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 48, 20))
+>second : Symbol(second, Decl(excessPropertyCheckWithUnions.ts, 48, 33))
+
+over = { a: 1, b: 1, first: "ok", third: "error" }
+>over : Symbol(over, Decl(excessPropertyCheckWithUnions.ts, 45, 3))
+>a : Symbol(a, Decl(excessPropertyCheckWithUnions.ts, 49, 8))
+>b : Symbol(b, Decl(excessPropertyCheckWithUnions.ts, 49, 14))
+>first : Symbol(first, Decl(excessPropertyCheckWithUnions.ts, 49, 20))
+>third : Symbol(third, Decl(excessPropertyCheckWithUnions.ts, 49, 33))
+

tests/baselines/reference/excessPropertyCheckWithUnions.types

@@ -0,0 +1,196 @@
+=== tests/cases/compiler/excessPropertyCheckWithUnions.ts ===
+type ADT = {
+>ADT : ADT
+
+    tag: "A",
+>tag : "A"
+
+    a1: string
+>a1 : string
+
+} | {
+    tag: "D",
+>tag : "D"
+
+    d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+>d20 : 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
+
+} | {
+    tag: "T",
+>tag : "T"
+}
+let wrong: ADT = { tag: "T", a1: "extra" }
+>wrong : ADT
+>ADT : ADT
+>{ tag: "T", a1: "extra" } : { tag: "T"; a1: string; }
+>tag : string
+>"T" : "T"
+>a1 : string
+>"extra" : "extra"
+
+wrong = { tag: "A", d20: 12 }
+>wrong = { tag: "A", d20: 12 } : { tag: "A"; d20: 12; }
+>wrong : ADT
+>{ tag: "A", d20: 12 } : { tag: "A"; d20: 12; }
+>tag : string
+>"A" : "A"
+>d20 : number
+>12 : 12
+
+wrong = { tag: "D" }
+>wrong = { tag: "D" } : { tag: "D"; }
+>wrong : ADT
+>{ tag: "D" } : { tag: "D"; }
+>tag : string
+>"D" : "D"
+
+type Ambiguous = {
+>Ambiguous : Ambiguous
+
+    tag: "A",
+>tag : "A"
+
+    x: string
+>x : string
+
+} | {
+    tag: "A",
+>tag : "A"
+
+    y: number
+>y : number
+
+} | {
+    tag: "B",
+>tag : "B"
+
+    z: boolean
+>z : boolean
+
+} | {
+    tag: "C"
+>tag : "C"
+}
+let amb: Ambiguous
+>amb : Ambiguous
+>Ambiguous : Ambiguous
+
+// no error for ambiguous tag, even when it could satisfy both constituents at once
+amb = { tag: "A", x: "hi" }
+>amb = { tag: "A", x: "hi" } : { tag: "A"; x: string; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi" } : { tag: "A"; x: string; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+
+amb = { tag: "A", y: 12 }
+>amb = { tag: "A", y: 12 } : { tag: "A"; y: number; }
+>amb : Ambiguous
+>{ tag: "A", y: 12 } : { tag: "A"; y: number; }
+>tag : string
+>"A" : "A"
+>y : number
+>12 : 12
+
+amb = { tag: "A", x: "hi", y: 12 }
+>amb = { tag: "A", x: "hi", y: 12 } : { tag: "A"; x: string; y: number; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi", y: 12 } : { tag: "A"; x: string; y: number; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+>y : number
+>12 : 12
+
+// correctly error on excess property 'extra', even when ambiguous
+amb = { tag: "A", x: "hi", extra: 12 }
+>amb = { tag: "A", x: "hi", extra: 12 } : { tag: "A"; x: string; extra: number; }
+>amb : Ambiguous
+>{ tag: "A", x: "hi", extra: 12 } : { tag: "A"; x: string; extra: number; }
+>tag : string
+>"A" : "A"
+>x : string
+>"hi" : "hi"
+>extra : number
+>12 : 12
+
+amb = { tag: "A", y: 12, extra: 12 }
+>amb = { tag: "A", y: 12, extra: 12 } : { tag: "A"; y: number; extra: number; }
+>amb : Ambiguous
+>{ tag: "A", y: 12, extra: 12 } : { tag: "A"; y: number; extra: number; }
+>tag : string
+>"A" : "A"
+>y : number
+>12 : 12
+>extra : number
+>12 : 12
+
+// assignability errors still work.
+// But note that the error for `z: true` is the fallback one of reporting on
+// the last constituent since assignability error reporting can't find a single best discriminant either.
+amb = { tag: "A" }
+>amb = { tag: "A" } : { tag: "A"; }
+>amb : Ambiguous
+>{ tag: "A" } : { tag: "A"; }
+>tag : string
+>"A" : "A"
+
+amb = { tag: "A", z: true }
+>amb = { tag: "A", z: true } : { tag: "A"; z: true; }
+>amb : Ambiguous
+>{ tag: "A", z: true } : { tag: "A"; z: true; }
+>tag : string
+>"A" : "A"
+>z : boolean
+>true : true
+
+type Overlapping =
+>Overlapping : Overlapping
+
+    | { a: 1, b: 1, first: string }
+>a : 1
+>b : 1
+>first : string
+
+    | { a: 2, second: string }
+>a : 2
+>second : string
+
+    | { b: 3, third: string }
+>b : 3
+>third : string
+
+let over: Overlapping
+>over : Overlapping
+>Overlapping : Overlapping
+
+// these two are not reported because there are two discriminant properties
+over = { a: 1, b: 1, first: "ok", second: "error" }
+>over = { a: 1, b: 1, first: "ok", second: "error" } : { a: 1; b: 1; first: string; second: string; }
+>over : Overlapping
+>{ a: 1, b: 1, first: "ok", second: "error" } : { a: 1; b: 1; first: string; second: string; }
+>a : number
+>1 : 1
+>b : number
+>1 : 1
+>first : string
+>"ok" : "ok"
+>second : string
+>"error" : "error"
+
+over = { a: 1, b: 1, first: "ok", third: "error" }
+>over = { a: 1, b: 1, first: "ok", third: "error" } : { a: 1; b: 1; first: string; third: string; }
+>over : Overlapping
+>{ a: 1, b: 1, first: "ok", third: "error" } : { a: 1; b: 1; first: string; third: string; }
+>a : number
+>1 : 1
+>b : number
+>1 : 1
+>first : string
+>"ok" : "ok"
+>third : string
+>"error" : "error"
+

tests/baselines/reference/exportDefaultVariable.symbols

@@ -6,6 +6,6 @@ declare var io: any;
 
 declare module 'module' {
     export default io;
->io : Symbol(default, Decl(exportDefaultVariable.ts, 2, 11))
+>io : Symbol(io, Decl(exportDefaultVariable.ts, 2, 11))
 }
 

tests/baselines/reference/genericContextualTypingSpecialization.symbols

@@ -3,9 +3,9 @@ var b: number[];
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
 
 b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
->b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
 >d : Symbol(d, Decl(genericContextualTypingSpecialization.ts, 1, 20))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))

tests/baselines/reference/genericContextualTypingSpecialization.types

@@ -4,9 +4,9 @@ var b: number[];
 
 b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
 >b.reduce<number>((c, d) => c + d, 0) : number
->b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >b : number[]
->reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >(c, d) => c + d : (c: number, d: number) => number
 >c : number
 >d : number

tests/baselines/reference/genericReduce.symbols

@@ -14,9 +14,9 @@ var b = a.map(s => s.length);
 
 var n1 = b.reduce((x, y) => x + y);
 >n1 : Symbol(n1, Decl(genericReduce.ts, 2, 3))
->b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericReduce.ts, 1, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericReduce.ts, 2, 19))
 >y : Symbol(y, Decl(genericReduce.ts, 2, 21))
 >x : Symbol(x, Decl(genericReduce.ts, 2, 19))
@@ -24,9 +24,9 @@ var n1 = b.reduce((x, y) => x + y);
 
 var n2 = b.reduceRight((x, y) => x + y);
 >n2 : Symbol(n2, Decl(genericReduce.ts, 3, 3))
->b.reduceRight : Symbol(Array.reduceRight, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>b.reduceRight : Symbol(Array.reduceRight, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericReduce.ts, 1, 3))
->reduceRight : Symbol(Array.reduceRight, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduceRight : Symbol(Array.reduceRight, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericReduce.ts, 3, 24))
 >y : Symbol(y, Decl(genericReduce.ts, 3, 26))
 >x : Symbol(x, Decl(genericReduce.ts, 3, 24))
@@ -50,9 +50,9 @@ n2.toExponential(2); // should not error if 'n2' is correctly number.
 
 var n3 = b.reduce<string>( (x, y) => x + y, ""); // Initial value is of type string
 >n3 : Symbol(n3, Decl(genericReduce.ts, 10, 3))
->b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericReduce.ts, 1, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericReduce.ts, 10, 28))
 >y : Symbol(y, Decl(genericReduce.ts, 10, 30))
 >x : Symbol(x, Decl(genericReduce.ts, 10, 28))

tests/baselines/reference/genericReduce.types

@@ -22,9 +22,9 @@ var b = a.map(s => s.length);
 var n1 = b.reduce((x, y) => x + y);
 >n1 : number
 >b.reduce((x, y) => x + y) : number
->b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >b : number[]
->reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >(x, y) => x + y : (x: number, y: number) => number
 >x : number
 >y : number
@@ -35,9 +35,9 @@ var n1 = b.reduce((x, y) => x + y);
 var n2 = b.reduceRight((x, y) => x + y);
 >n2 : number
 >b.reduceRight((x, y) => x + y) : number
->b.reduceRight : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>b.reduceRight : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >b : number[]
->reduceRight : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>reduceRight : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >(x, y) => x + y : (x: number, y: number) => number
 >x : number
 >y : number
@@ -76,9 +76,9 @@ n2.toExponential(2); // should not error if 'n2' is correctly number.
 var n3 = b.reduce<string>( (x, y) => x + y, ""); // Initial value is of type string
 >n3 : string
 >b.reduce<string>( (x, y) => x + y, "") : string
->b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >b : number[]
->reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >(x, y) => x + y : (x: string, y: number) => string
 >x : string
 >y : number

tests/baselines/reference/importCallExpressionAsyncES6AMD.js

@@ -42,34 +42,34 @@ define(["require", "exports"], function (require, exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
     function fn() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = yield new Promise(function (resolve_1, reject_1) { require(['./test'], resolve_1, reject_1); }); // ONE
+            const req = yield new Promise((resolve_1, reject_1) => { require(['./test'], resolve_1, reject_1); }); // ONE
         });
     }
     exports.fn = fn;
     class cl1 {
         m() {
             return __awaiter(this, void 0, void 0, function* () {
-                const req = yield new Promise(function (resolve_2, reject_2) { require(['./test'], resolve_2, reject_2); }); // TWO
+                const req = yield new Promise((resolve_2, reject_2) => { require(['./test'], resolve_2, reject_2); }); // TWO
             });
         }
     }
     exports.cl1 = cl1;
     exports.obj = {
         m: () => __awaiter(this, void 0, void 0, function* () {
-            const req = yield new Promise(function (resolve_3, reject_3) { require(['./test'], resolve_3, reject_3); }); // THREE
+            const req = yield new Promise((resolve_3, reject_3) => { require(['./test'], resolve_3, reject_3); }); // THREE
         })
     };
     class cl2 {
         constructor() {
             this.p = {
                 m: () => __awaiter(this, void 0, void 0, function* () {
-                    const req = yield new Promise(function (resolve_4, reject_4) { require(['./test'], resolve_4, reject_4); }); // FOUR
+                    const req = yield new Promise((resolve_4, reject_4) => { require(['./test'], resolve_4, reject_4); }); // FOUR
                 })
             };
         }
     }
     exports.cl2 = cl2;
     exports.l = () => __awaiter(this, void 0, void 0, function* () {
-        const req = yield new Promise(function (resolve_5, reject_5) { require(['./test'], resolve_5, reject_5); }); // FIVE
+        const req = yield new Promise((resolve_5, reject_5) => { require(['./test'], resolve_5, reject_5); }); // FIVE
     });
 });

tests/baselines/reference/importCallExpressionAsyncES6CJS.js

@@ -41,33 +41,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function fn() {
     return __awaiter(this, void 0, void 0, function* () {
-        const req = yield Promise.resolve().then(function () { return require('./test'); }); // ONE
+        const req = yield Promise.resolve().then(() => require('./test')); // ONE
     });
 }
 exports.fn = fn;
 class cl1 {
     m() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = yield Promise.resolve().then(function () { return require('./test'); }); // TWO
+            const req = yield Promise.resolve().then(() => require('./test')); // TWO
         });
     }
 }
 exports.cl1 = cl1;
 exports.obj = {
     m: () => __awaiter(this, void 0, void 0, function* () {
-        const req = yield Promise.resolve().then(function () { return require('./test'); }); // THREE
+        const req = yield Promise.resolve().then(() => require('./test')); // THREE
     })
 };
 class cl2 {
     constructor() {
         this.p = {
             m: () => __awaiter(this, void 0, void 0, function* () {
-                const req = yield Promise.resolve().then(function () { return require('./test'); }); // FOUR
+                const req = yield Promise.resolve().then(() => require('./test')); // FOUR
             })
         };
     }
 }
 exports.cl2 = cl2;
 exports.l = () => __awaiter(this, void 0, void 0, function* () {
-    const req = yield Promise.resolve().then(function () { return require('./test'); }); // FIVE
+    const req = yield Promise.resolve().then(() => require('./test')); // FIVE
 });

tests/baselines/reference/importCallExpressionAsyncES6UMD.js

@@ -51,34 +51,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     Object.defineProperty(exports, "__esModule", { value: true });
     function fn() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = yield __syncRequire ? Promise.resolve().then(function () { return require('./test'); }) : new Promise(function (resolve_1, reject_1) { require(['./test'], resolve_1, reject_1); }); // ONE
+            const req = yield __syncRequire ? Promise.resolve().then(() => require('./test')) : new Promise((resolve_1, reject_1) => { require(['./test'], resolve_1, reject_1); }); // ONE
         });
     }
     exports.fn = fn;
     class cl1 {
         m() {
             return __awaiter(this, void 0, void 0, function* () {
-                const req = yield __syncRequire ? Promise.resolve().then(function () { return require('./test'); }) : new Promise(function (resolve_2, reject_2) { require(['./test'], resolve_2, reject_2); }); // TWO
+                const req = yield __syncRequire ? Promise.resolve().then(() => require('./test')) : new Promise((resolve_2, reject_2) => { require(['./test'], resolve_2, reject_2); }); // TWO
             });
         }
     }
     exports.cl1 = cl1;
     exports.obj = {
         m: () => __awaiter(this, void 0, void 0, function* () {
-            const req = yield __syncRequire ? Promise.resolve().then(function () { return require('./test'); }) : new Promise(function (resolve_3, reject_3) { require(['./test'], resolve_3, reject_3); }); // THREE
+            const req = yield __syncRequire ? Promise.resolve().then(() => require('./test')) : new Promise((resolve_3, reject_3) => { require(['./test'], resolve_3, reject_3); }); // THREE
         })
     };
     class cl2 {
         constructor() {
             this.p = {
                 m: () => __awaiter(this, void 0, void 0, function* () {
-                    const req = yield __syncRequire ? Promise.resolve().then(function () { return require('./test'); }) : new Promise(function (resolve_4, reject_4) { require(['./test'], resolve_4, reject_4); }); // FOUR
+                    const req = yield __syncRequire ? Promise.resolve().then(() => require('./test')) : new Promise((resolve_4, reject_4) => { require(['./test'], resolve_4, reject_4); }); // FOUR
                 })
             };
         }
     }
     exports.cl2 = cl2;
     exports.l = () => __awaiter(this, void 0, void 0, function* () {
-        const req = yield __syncRequire ? Promise.resolve().then(function () { return require('./test'); }) : new Promise(function (resolve_5, reject_5) { require(['./test'], resolve_5, reject_5); }); // FIVE
+        const req = yield __syncRequire ? Promise.resolve().then(() => require('./test')) : new Promise((resolve_5, reject_5) => { require(['./test'], resolve_5, reject_5); }); // FIVE
     });
 });

tests/baselines/reference/importCallExpressionCheckReturntype1.js

@@ -30,6 +30,6 @@ exports.C = C;
 //// [1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-let p1 = Promise.resolve().then(function () { return require("./defaultPath"); });
-let p2 = Promise.resolve().then(function () { return require("./defaultPath"); });
-let p3 = Promise.resolve().then(function () { return require("./defaultPath"); });
+let p1 = Promise.resolve().then(() => require("./defaultPath"));
+let p2 = Promise.resolve().then(() => require("./defaultPath"));
+let p3 = Promise.resolve().then(() => require("./defaultPath"));

tests/baselines/reference/importCallExpressionDeclarationEmit1.js

@@ -15,12 +15,12 @@ function returnDynamicLoad(path: string) {
 }
 
 //// [importCallExpressionDeclarationEmit1.js]
-Promise.resolve().then(function () { return require(getSpecifier()); });
-var p0 = Promise.resolve().then(function () { return require(`${directory}\${moduleFile}`); });
-var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
-const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+Promise.resolve().then(() => require(getSpecifier()));
+var p0 = Promise.resolve().then(() => require(`${directory}\${moduleFile}`));
+var p1 = Promise.resolve().then(() => require(getSpecifier()));
+const p2 = Promise.resolve().then(() => require(whatToLoad ? getSpecifier() : "defaulPath"));
 function returnDynamicLoad(path) {
-    return Promise.resolve().then(function () { return require(path); });
+    return Promise.resolve().then(() => require(path));
 }
 
 

tests/baselines/reference/importCallExpressionES6AMD.js

@@ -39,23 +39,23 @@ define(["require", "exports"], function (require, exports) {
 define(["require", "exports"], function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
-    var p1 = new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
+    var p1 = new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
     p1.then(zero => {
         return zero.foo();
     });
-    exports.p2 = new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    exports.p2 = new Promise((resolve_3, reject_3) => { require(["./0"], resolve_3, reject_3); });
     function foo() {
-        const p2 = new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+        const p2 = new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
     }
     class C {
         method() {
-            const loadAsync = new Promise(function (resolve_5, reject_5) { require(["./0"], resolve_5, reject_5); });
+            const loadAsync = new Promise((resolve_5, reject_5) => { require(["./0"], resolve_5, reject_5); });
         }
     }
     class D {
         method() {
-            const loadAsync = new Promise(function (resolve_6, reject_6) { require(["./0"], resolve_6, reject_6); });
+            const loadAsync = new Promise((resolve_6, reject_6) => { require(["./0"], resolve_6, reject_6); });
         }
     }
     exports.D = D;

tests/baselines/reference/importCallExpressionES6CJS.js

@@ -36,23 +36,23 @@ exports.foo = foo;
 //// [1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Promise.resolve().then(function () { return require("./0"); });
-var p1 = Promise.resolve().then(function () { return require("./0"); });
+Promise.resolve().then(() => require("./0"));
+var p1 = Promise.resolve().then(() => require("./0"));
 p1.then(zero => {
     return zero.foo();
 });
-exports.p2 = Promise.resolve().then(function () { return require("./0"); });
+exports.p2 = Promise.resolve().then(() => require("./0"));
 function foo() {
-    const p2 = Promise.resolve().then(function () { return require("./0"); });
+    const p2 = Promise.resolve().then(() => require("./0"));
 }
 class C {
     method() {
-        const loadAsync = Promise.resolve().then(function () { return require("./0"); });
+        const loadAsync = Promise.resolve().then(() => require("./0"));
     }
 }
 class D {
     method() {
-        const loadAsync = Promise.resolve().then(function () { return require("./0"); });
+        const loadAsync = Promise.resolve().then(() => require("./0"));
     }
 }
 exports.D = D;

tests/baselines/reference/importCallExpressionES6UMD.js

@@ -56,23 +56,23 @@ export class D {
     "use strict";
     var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
-    __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
-    var p1 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
+    var p1 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
     p1.then(zero => {
         return zero.foo();
     });
-    exports.p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    exports.p2 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_3, reject_3) => { require(["./0"], resolve_3, reject_3); });
     function foo() {
-        const p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+        const p2 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
     }
     class C {
         method() {
-            const loadAsync = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_5, reject_5) { require(["./0"], resolve_5, reject_5); });
+            const loadAsync = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_5, reject_5) => { require(["./0"], resolve_5, reject_5); });
         }
     }
     class D {
         method() {
-            const loadAsync = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_6, reject_6) { require(["./0"], resolve_6, reject_6); });
+            const loadAsync = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_6, reject_6) => { require(["./0"], resolve_6, reject_6); });
         }
     }
     exports.D = D;

tests/baselines/reference/importCallExpressionGrammarError.js

@@ -12,8 +12,8 @@ const p4 = import("pathToModule", "secondModule");
 
 //// [importCallExpressionGrammarError.js]
 var a = ["./0"];
-Promise.resolve().then(function () { return require(...["PathModule"]); });
-var p1 = Promise.resolve().then(function () { return require(...a); });
-const p2 = Promise.resolve().then(function () { return require(); });
-const p3 = Promise.resolve().then(function () { return require(); });
-const p4 = Promise.resolve().then(function () { return require("pathToModule", "secondModule"); });
+Promise.resolve().then(() => require(...["PathModule"]));
+var p1 = Promise.resolve().then(() => require(...a));
+const p2 = Promise.resolve().then(() => require());
+const p3 = Promise.resolve().then(() => require());
+const p4 = Promise.resolve().then(() => require("pathToModule", "secondModule"));

tests/baselines/reference/importCallExpressionInAMD1.js

@@ -27,13 +27,13 @@ define(["require", "exports"], function (require, exports) {
 define(["require", "exports"], function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
-    var p1 = new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
+    var p1 = new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
     p1.then(zero => {
         return zero.foo();
     });
-    exports.p2 = new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    exports.p2 = new Promise((resolve_3, reject_3) => { require(["./0"], resolve_3, reject_3); });
     function foo() {
-        const p2 = new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+        const p2 = new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
     }
 });

tests/baselines/reference/importCallExpressionInAMD2.js

@@ -35,5 +35,5 @@ define(["require", "exports"], function (require, exports) {
             b.print();
         });
     }
-    foo(new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }));
+    foo(new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); }));
 });

tests/baselines/reference/importCallExpressionInAMD3.js

@@ -26,7 +26,7 @@ define(["require", "exports"], function (require, exports) {
 define(["require", "exports"], function (require, exports) {
     "use strict";
     async function foo() {
-        class C extends (await new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); })).B {
+        class C extends (await new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); })).B {
         }
         var c = new C();
         c.print();

tests/baselines/reference/importCallExpressionInAMD4.js

@@ -64,30 +64,30 @@ define(["require", "exports"], function (require, exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
     class C {
         constructor() {
-            this.myModule = new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+            this.myModule = new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
         }
         method() {
-            const loadAsync = new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+            const loadAsync = new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
             this.myModule.then(Zero => {
                 console.log(Zero.foo());
             }, async (err) => {
                 console.log(err);
-                let one = await new Promise(function (resolve_3, reject_3) { require(["./1"], resolve_3, reject_3); });
+                let one = await new Promise((resolve_3, reject_3) => { require(["./1"], resolve_3, reject_3); });
                 console.log(one.backup());
             });
         }
     }
     class D {
         constructor() {
-            this.myModule = new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+            this.myModule = new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
         }
         method() {
-            const loadAsync = new Promise(function (resolve_5, reject_5) { require(["./0"], resolve_5, reject_5); });
+            const loadAsync = new Promise((resolve_5, reject_5) => { require(["./0"], resolve_5, reject_5); });
             this.myModule.then(Zero => {
                 console.log(Zero.foo());
             }, async (err) => {
                 console.log(err);
-                let one = await new Promise(function (resolve_6, reject_6) { require(["./1"], resolve_6, reject_6); });
+                let one = await new Promise((resolve_6, reject_6) => { require(["./1"], resolve_6, reject_6); });
                 console.log(one.backup());
             });
         }

tests/baselines/reference/importCallExpressionInCJS1.js

@@ -24,12 +24,12 @@ exports.foo = foo;
 //// [1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Promise.resolve().then(function () { return require("./0"); });
-var p1 = Promise.resolve().then(function () { return require("./0"); });
+Promise.resolve().then(() => require("./0"));
+var p1 = Promise.resolve().then(() => require("./0"));
 p1.then(zero => {
     return zero.foo();
 });
-exports.p2 = Promise.resolve().then(function () { return require("./0"); });
+exports.p2 = Promise.resolve().then(() => require("./0"));
 function foo() {
-    const p2 = Promise.resolve().then(function () { return require("./0"); });
+    const p2 = Promise.resolve().then(() => require("./0"));
 }

tests/baselines/reference/importCallExpressionInCJS2.js

@@ -32,9 +32,9 @@ exports.backup = backup;
 async function compute(promise) {
     let j = await promise;
     if (!j) {
-        j = await Promise.resolve().then(function () { return require("./1"); });
+        j = await Promise.resolve().then(() => require("./1"));
         return j.backup();
     }
     return j.foo();
 }
-compute(Promise.resolve().then(function () { return require("./0"); }));
+compute(Promise.resolve().then(() => require("./0")));

tests/baselines/reference/importCallExpressionInCJS3.js

@@ -31,4 +31,4 @@ function foo(x) {
         b.print();
     });
 }
-foo(Promise.resolve().then(function () { return require("./0"); }));
+foo(Promise.resolve().then(() => require("./0")));

tests/baselines/reference/importCallExpressionInCJS4.js

@@ -22,7 +22,7 @@ class B {
 exports.B = B;
 //// [2.js]
 async function foo() {
-    class C extends (await Promise.resolve().then(function () { return require("./0"); })).B {
+    class C extends (await Promise.resolve().then(() => require("./0"))).B {
     }
     var c = new C();
     c.print();

tests/baselines/reference/importCallExpressionInCJS5.js

@@ -59,30 +59,30 @@ exports.backup = backup;
 Object.defineProperty(exports, "__esModule", { value: true });
 class C {
     constructor() {
-        this.myModule = Promise.resolve().then(function () { return require("./0"); });
+        this.myModule = Promise.resolve().then(() => require("./0"));
     }
     method() {
-        const loadAsync = Promise.resolve().then(function () { return require("./0"); });
+        const loadAsync = Promise.resolve().then(() => require("./0"));
         this.myModule.then(Zero => {
             console.log(Zero.foo());
         }, async (err) => {
             console.log(err);
-            let one = await Promise.resolve().then(function () { return require("./1"); });
+            let one = await Promise.resolve().then(() => require("./1"));
             console.log(one.backup());
         });
     }
 }
 class D {
     constructor() {
-        this.myModule = Promise.resolve().then(function () { return require("./0"); });
+        this.myModule = Promise.resolve().then(() => require("./0"));
     }
     method() {
-        const loadAsync = Promise.resolve().then(function () { return require("./0"); });
+        const loadAsync = Promise.resolve().then(() => require("./0"));
         this.myModule.then(Zero => {
             console.log(Zero.foo());
         }, async (err) => {
             console.log(err);
-            let one = await Promise.resolve().then(function () { return require("./1"); });
+            let one = await Promise.resolve().then(() => require("./1"));
             console.log(one.backup());
         });
     }

tests/baselines/reference/importCallExpressionInExportEqualsAMD.js

@@ -17,6 +17,6 @@ define(["require", "exports"], function (require, exports) {
 define(["require", "exports"], function (require, exports) {
     "use strict";
     return async function () {
-        const something = await new Promise(function (resolve_1, reject_1) { require(["./something"], resolve_1, reject_1); });
+        const something = await new Promise((resolve_1, reject_1) => { require(["./something"], resolve_1, reject_1); });
     };
 });

tests/baselines/reference/importCallExpressionInExportEqualsCJS.js

@@ -14,5 +14,5 @@ module.exports = 42;
 //// [index.js]
 "use strict";
 module.exports = async function () {
-    const something = await Promise.resolve().then(function () { return require("./something"); });
+    const something = await Promise.resolve().then(() => require("./something"));
 };

tests/baselines/reference/importCallExpressionInExportEqualsUMD.js

@@ -34,6 +34,6 @@ export = async function() {
     "use strict";
     var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     return async function () {
-        const something = await (__syncRequire ? Promise.resolve().then(function () { return require("./something"); }) : new Promise(function (resolve_1, reject_1) { require(["./something"], resolve_1, reject_1); }));
+        const something = await (__syncRequire ? Promise.resolve().then(() => require("./something")) : new Promise((resolve_1, reject_1) => { require(["./something"], resolve_1, reject_1); }));
     };
 });

tests/baselines/reference/importCallExpressionInScriptContext1.js

@@ -13,5 +13,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function foo() { return "foo"; }
 exports.foo = foo;
 //// [1.js]
-var p1 = Promise.resolve().then(function () { return require("./0"); });
+var p1 = Promise.resolve().then(() => require("./0"));
 function arguments() { } // this is allow as the file doesn't have implicit "use strict"

tests/baselines/reference/importCallExpressionInScriptContext2.js

@@ -15,5 +15,5 @@ function foo() { return "foo"; }
 exports.foo = foo;
 //// [1.js]
 "use strict";
-var p1 = Promise.resolve().then(function () { return require("./0"); });
+var p1 = Promise.resolve().then(() => require("./0"));
 function arguments() { }

tests/baselines/reference/importCallExpressionInUMD1.js

@@ -44,13 +44,13 @@ function foo() {
     "use strict";
     var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
-    __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
-    var p1 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+    __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
+    var p1 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
     p1.then(zero => {
         return zero.foo();
     });
-    exports.p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_3, reject_3) { require(["./0"], resolve_3, reject_3); });
+    exports.p2 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_3, reject_3) => { require(["./0"], resolve_3, reject_3); });
     function foo() {
-        const p2 = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+        const p2 = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
     }
 });

tests/baselines/reference/importCallExpressionInUMD2.js

@@ -52,5 +52,5 @@ foo(import("./0"));
             b.print();
         });
     }
-    foo(__syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }));
+    foo(__syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); }));
 });

tests/baselines/reference/importCallExpressionInUMD3.js

@@ -43,7 +43,7 @@ foo();
     "use strict";
     var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     async function foo() {
-        class C extends (await (__syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); }))).B {
+        class C extends (await (__syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); }))).B {
         }
         var c = new C();
         c.print();

tests/baselines/reference/importCallExpressionInUMD4.js

@@ -89,30 +89,30 @@ export class D {
     Object.defineProperty(exports, "__esModule", { value: true });
     class C {
         constructor() {
-            this.myModule = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_1, reject_1) { require(["./0"], resolve_1, reject_1); });
+            this.myModule = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_1, reject_1) => { require(["./0"], resolve_1, reject_1); });
         }
         method() {
-            const loadAsync = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_2, reject_2) { require(["./0"], resolve_2, reject_2); });
+            const loadAsync = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_2, reject_2) => { require(["./0"], resolve_2, reject_2); });
             this.myModule.then(Zero => {
                 console.log(Zero.foo());
             }, async (err) => {
                 console.log(err);
-                let one = await (__syncRequire ? Promise.resolve().then(function () { return require("./1"); }) : new Promise(function (resolve_3, reject_3) { require(["./1"], resolve_3, reject_3); }));
+                let one = await (__syncRequire ? Promise.resolve().then(() => require("./1")) : new Promise((resolve_3, reject_3) => { require(["./1"], resolve_3, reject_3); }));
                 console.log(one.backup());
             });
         }
     }
     class D {
         constructor() {
-            this.myModule = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_4, reject_4) { require(["./0"], resolve_4, reject_4); });
+            this.myModule = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_4, reject_4) => { require(["./0"], resolve_4, reject_4); });
         }
         method() {
-            const loadAsync = __syncRequire ? Promise.resolve().then(function () { return require("./0"); }) : new Promise(function (resolve_5, reject_5) { require(["./0"], resolve_5, reject_5); });
+            const loadAsync = __syncRequire ? Promise.resolve().then(() => require("./0")) : new Promise((resolve_5, reject_5) => { require(["./0"], resolve_5, reject_5); });
             this.myModule.then(Zero => {
                 console.log(Zero.foo());
             }, async (err) => {
                 console.log(err);
-                let one = await (__syncRequire ? Promise.resolve().then(function () { return require("./1"); }) : new Promise(function (resolve_6, reject_6) { require(["./1"], resolve_6, reject_6); }));
+                let one = await (__syncRequire ? Promise.resolve().then(() => require("./1")) : new Promise((resolve_6, reject_6) => { require(["./1"], resolve_6, reject_6); }));
                 console.log(one.backup());
             });
         }

tests/baselines/reference/importCallExpressionReturnPromiseOfAny.js

@@ -42,20 +42,20 @@ exports.C = C;
 //// [1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Promise.resolve().then(function () { return require(`${directory}\${moduleFile}`); });
-Promise.resolve().then(function () { return require(getSpecifier()); });
-var p1 = Promise.resolve().then(function () { return require(ValidSomeCondition() ? "./0" : "externalModule"); });
-var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
-var p11 = Promise.resolve().then(function () { return require(getSpecifier()); });
-const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+Promise.resolve().then(() => require(`${directory}\${moduleFile}`));
+Promise.resolve().then(() => require(getSpecifier()));
+var p1 = Promise.resolve().then(() => require(ValidSomeCondition() ? "./0" : "externalModule"));
+var p1 = Promise.resolve().then(() => require(getSpecifier()));
+var p11 = Promise.resolve().then(() => require(getSpecifier()));
+const p2 = Promise.resolve().then(() => require(whatToLoad ? getSpecifier() : "defaulPath"));
 p1.then(zero => {
     return zero.foo(); // ok, zero is any
 });
 let j;
-var p3 = Promise.resolve().then(function () { return require(j = getSpecifier()); });
+var p3 = Promise.resolve().then(() => require(j = getSpecifier()));
 function* loadModule(directories) {
     for (const directory of directories) {
         const path = `${directory}\moduleFile`;
-        Promise.resolve().then(function () { return require(yield path); });
+        Promise.resolve().then(() => require(yield path));
     }
 }

tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.js

@@ -15,11 +15,11 @@ var p4 = import(()=>"PathToModule");
 
 //// [importCallExpressionSpecifierNotStringTypeError.js]
 // Error specifier is not assignable to string
-Promise.resolve().then(function () { return require(getSpecifier()); });
-var p1 = Promise.resolve().then(function () { return require(getSpecifier()); });
-const p2 = Promise.resolve().then(function () { return require(whatToLoad ? getSpecifier() : "defaulPath"); });
+Promise.resolve().then(() => require(getSpecifier()));
+var p1 = Promise.resolve().then(() => require(getSpecifier()));
+const p2 = Promise.resolve().then(() => require(whatToLoad ? getSpecifier() : "defaulPath"));
 p1.then(zero => {
     return zero.foo(); // ok, zero is any
 });
-var p3 = Promise.resolve().then(function () { return require(["path1", "path2"]); });
-var p4 = Promise.resolve().then(function () { return require(() => "PathToModule"); });
+var p3 = Promise.resolve().then(() => require(["path1", "path2"]));
+var p4 = Promise.resolve().then(() => require(() => "PathToModule"));

tests/baselines/reference/importCallExpressionWithTypeArgument.js

@@ -15,5 +15,5 @@ function foo() { return "foo"; }
 exports.foo = foo;
 //// [1.js]
 "use strict";
-var p1 = Promise.resolve().then(function () { return require("./0"); }); // error
-var p2 = Promise.resolve().then(function () { return require("./0"); }); // error
+var p1 = Promise.resolve().then(() => require("./0")); // error
+var p2 = Promise.resolve().then(() => require("./0")); // error

tests/baselines/reference/inferFromGenericFunctionReturnTypes1.symbols

@@ -124,9 +124,9 @@ function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
   return (x: T) => fns.reduce((prev, fn) => fn(prev), x);
 >x : Symbol(x, Decl(inferFromGenericFunctionReturnTypes1.ts, 27, 10))
 >T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes1.ts, 26, 17))
->fns.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>fns.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fns : Symbol(fns, Decl(inferFromGenericFunctionReturnTypes1.ts, 26, 20))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prev : Symbol(prev, Decl(inferFromGenericFunctionReturnTypes1.ts, 27, 31))
 >fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes1.ts, 27, 36))
 >fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes1.ts, 27, 36))

tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types

@@ -131,9 +131,9 @@ function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
 >x : T
 >T : T
 >fns.reduce((prev, fn) => fn(prev), x) : T
->fns.reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>fns.reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T): (x: T) => T; (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >fns : ((x: T) => T)[]
->reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T): (x: T) => T; (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >(prev, fn) => fn(prev) : (prev: T, fn: (x: T) => T) => T
 >prev : T
 >fn : (x: T) => T

tests/baselines/reference/inferFromGenericFunctionReturnTypes2.symbols

@@ -292,9 +292,9 @@ function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
   return (x: T) => fns.reduce((prev, fn) => fn(prev), x);
 >x : Symbol(x, Decl(inferFromGenericFunctionReturnTypes2.ts, 49, 10))
 >T : Symbol(T, Decl(inferFromGenericFunctionReturnTypes2.ts, 48, 17))
->fns.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>fns.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fns : Symbol(fns, Decl(inferFromGenericFunctionReturnTypes2.ts, 48, 20))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >prev : Symbol(prev, Decl(inferFromGenericFunctionReturnTypes2.ts, 49, 31))
 >fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes2.ts, 49, 36))
 >fn : Symbol(fn, Decl(inferFromGenericFunctionReturnTypes2.ts, 49, 36))

tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types

@@ -358,9 +358,9 @@ function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
 >x : T
 >T : T
 >fns.reduce((prev, fn) => fn(prev), x) : T
->fns.reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>fns.reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T): (x: T) => T; (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >fns : ((x: T) => T)[]
->reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T): (x: T) => T; (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >(prev, fn) => fn(prev) : (prev: T, fn: (x: T) => T) => T
 >prev : T
 >fn : (x: T) => T

tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.errors.txt

@@ -1,6 +1,6 @@
 tests/cases/compiler/a.js(1,22): error TS2528: A module cannot have multiple default exports.
 tests/cases/compiler/a.js(1,22): error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
-tests/cases/compiler/a.js(3,1): error TS2528: A module cannot have multiple default exports.
+tests/cases/compiler/a.js(3,15): error TS2528: A module cannot have multiple default exports.
 tests/cases/compiler/a.js(3,16): error TS1109: Expression expected.
 tests/cases/compiler/a.js(3,20): error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
 
@@ -13,7 +13,7 @@ tests/cases/compiler/a.js(3,20): error TS2652: Merged declaration 'a' cannot inc
 !!! error TS2652: Merged declaration 'a' cannot include a default export declaration. Consider adding a separate 'export default a' declaration instead.
     }
     export default var a = 10;
-    ~~~~~~~~~~~~~~
+                  
 !!! error TS2528: A module cannot have multiple default exports.
                    ~~~
 !!! error TS1109: Expression expected.