Merge branch 'master' into optimizeForEachChild

Jakefile.js

@@ -138,6 +138,7 @@ var harnessSources = harnessCoreSources.concat([
     "telemetry.ts",
     "transform.ts",
     "customTransforms.ts",
+    "programMissingFiles.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
@@ -286,7 +287,7 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
         var startCompileTime = mark();
         opts = opts || {};
         var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
-        var options = "--noImplicitAny --noImplicitThis --noEmitOnError --types "
+        var options = "--noImplicitAny --noImplicitThis --alwaysStrict --noEmitOnError --types "
         if (opts.types) {
             options += opts.types.join(",");
         }

README.md

@@ -6,7 +6,7 @@
 
 [![Join the chat at https://gitter.im/Microsoft/TypeScript](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/Microsoft/TypeScript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-[TypeScript](http://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](http://www.typescriptlang.org/Playground), and stay up to date via [our blog](https://blogs.msdn.microsoft.com/typescript) and [Twitter account](https://twitter.com/typescriptlang).
+[TypeScript](https://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](https://www.typescriptlang.org/play/), and stay up to date via [our blog](https://blogs.msdn.microsoft.com/typescript) and [Twitter account](https://twitter.com/typescriptlang).
 
 ## Installing
 
@@ -27,8 +27,8 @@ npm install -g typescript@next
 There are many ways to [contribute](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md) to TypeScript.
 * [Submit bugs](https://github.com/Microsoft/TypeScript/issues) and help us verify fixes as they are checked in.
 * Review the [source code changes](https://github.com/Microsoft/TypeScript/pulls).
-* Engage with other TypeScript users and developers on [StackOverflow](http://stackoverflow.com/questions/tagged/typescript). 
-* Join the [#typescript](http://twitter.com/#!/search/realtime/%23typescript) discussion on Twitter.
+* Engage with other TypeScript users and developers on [StackOverflow](https://stackoverflow.com/questions/tagged/typescript). 
+* Join the [#typescript](https://twitter.com/#!/search/realtime/%23typescript) discussion on Twitter.
 * [Contribute bug fixes](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md).
 * Read the language specification ([docx](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.docx?raw=true),
  [pdf](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.pdf?raw=true), [md](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)).
@@ -39,14 +39,14 @@ with any additional questions or comments.
 
 ## Documentation
 
-*  [Quick tutorial](http://www.typescriptlang.org/docs/tutorial.html)
-*  [Programming handbook](http://www.typescriptlang.org/docs/handbook/basic-types.html)
+*  [Quick tutorial](https://www.typescriptlang.org/docs/tutorial.html)
+*  [Programming handbook](https://www.typescriptlang.org/docs/handbook/basic-types.html)
 *  [Language specification](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
-*  [Homepage](http://www.typescriptlang.org/)
+*  [Homepage](https://www.typescriptlang.org/)
 
 ## Building
 
-In order to build the TypeScript compiler, ensure that you have [Git](http://git-scm.com/downloads) and [Node.js](http://nodejs.org/) installed.
+In order to build the TypeScript compiler, ensure that you have [Git](https://git-scm.com/downloads) and [Node.js](https://nodejs.org/) installed.
 
 Clone a copy of the repo:
 

package.json

@@ -34,7 +34,7 @@
         "@types/convert-source-map": "latest",
         "@types/del": "latest",
         "@types/glob": "latest",
-        "@types/gulp": "latest",
+        "@types/gulp": "3.X",
         "@types/gulp-concat": "latest",
         "@types/gulp-help": "latest",
         "@types/gulp-newer": "latest",
@@ -52,7 +52,7 @@
         "chai": "latest",
         "convert-source-map": "latest",
         "del": "latest",
-        "gulp": "latest",
+        "gulp": "3.X",
         "gulp-clone": "latest",
         "gulp-concat": "latest",
         "gulp-help": "latest",

src/compiler/binder.ts

@@ -2080,22 +2080,6 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
 
-                case SyntaxKind.SpreadAssignment:
-                case SyntaxKind.JsxSpreadAttribute:
-                    let root = container;
-                    let hasRest = false;
-                    while (root.parent) {
-                        if (root.kind === SyntaxKind.ObjectLiteralExpression &&
-                            root.parent.kind === SyntaxKind.BinaryExpression &&
-                            (root.parent as BinaryExpression).operatorToken.kind === SyntaxKind.EqualsToken &&
-                            (root.parent as BinaryExpression).left === root) {
-                            hasRest = true;
-                            break;
-                        }
-                        root = root.parent;
-                    }
-                    return;
-
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.ConstructSignature:
                 case SyntaxKind.IndexSignature:
@@ -2321,16 +2305,16 @@ namespace ts {
                 if (symbol && symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.VariableDeclaration) {
                     const declaration = symbol.valueDeclaration as VariableDeclaration;
                     if (declaration.initializer) {
-                        return isExportsOrModuleExportsOrAliasOrAssignemnt(declaration.initializer);
+                        return isExportsOrModuleExportsOrAliasOrAssignment(declaration.initializer);
                     }
                 }
             }
             return false;
         }
 
-        function isExportsOrModuleExportsOrAliasOrAssignemnt(node: Node): boolean {
+        function isExportsOrModuleExportsOrAliasOrAssignment(node: Node): boolean {
             return isExportsOrModuleExportsOrAlias(node) ||
-                (isAssignmentExpression(node, /*excludeCompoundAssignements*/ true) && (isExportsOrModuleExportsOrAliasOrAssignemnt(node.left) || isExportsOrModuleExportsOrAliasOrAssignemnt(node.right)));
+                (isAssignmentExpression(node, /*excludeCompoundAssignements*/ true) && (isExportsOrModuleExportsOrAliasOrAssignment(node.left) || isExportsOrModuleExportsOrAliasOrAssignment(node.right)));
         }
 
         function bindModuleExportsAssignment(node: BinaryExpression) {
@@ -3613,4 +3597,4 @@ namespace ts {
         child.parent = parent;
         forEachChild(child, (childsChild) => setParentPointers(child, childsChild));
     }
-}
+}

src/compiler/checker.ts

@@ -75,6 +75,9 @@ namespace ts {
         undefinedSymbol.declarations = [];
         const argumentsSymbol = createSymbol(SymbolFlags.Property, "arguments");
 
+        /** This will be set during calls to `getResolvedSignature` where services determines an apparent number of arguments greater than what is actually provided. */
+        let apparentArgumentCount: number | undefined;
+
         // for public members that accept a Node or one of its subtypes, we must guard against
         // synthetic nodes created during transformations by calling `getParseTreeNode`.
         // for most of these, we perform the guard only on `checker` to avoid any possible
@@ -160,9 +163,12 @@ namespace ts {
                 return node ? getContextualType(node) : undefined;
             },
             getFullyQualifiedName,
-            getResolvedSignature: (node, candidatesOutArray?) => {
+            getResolvedSignature: (node, candidatesOutArray, theArgumentCount) => {
                 node = getParseTreeNode(node, isCallLikeExpression);
-                return node ? getResolvedSignature(node, candidatesOutArray) : undefined;
+                apparentArgumentCount = theArgumentCount;
+                const res = node ? getResolvedSignature(node, candidatesOutArray) : undefined;
+                apparentArgumentCount = undefined;
+                return res;
             },
             getConstantValue: node => {
                 node = getParseTreeNode(node, canHaveConstantValue);
@@ -1122,7 +1128,7 @@ namespace ts {
                     return undefined;
                 }
 
-                // Only check for block-scoped variable if we are looking for the
+                // Only check for block-scoped variable if we have an error location and are looking for the
                 // name with variable meaning
                 //      For example,
                 //          declare module foo {
@@ -1133,8 +1139,9 @@ namespace ts {
                 // block-scoped variable and namespace module. However, only when we
                 // try to resolve name in /*1*/ which is used in variable position,
                 // we want to check for block-scoped
-                if (meaning & SymbolFlags.BlockScopedVariable ||
-                    ((meaning & SymbolFlags.Class || meaning & SymbolFlags.Enum) && (meaning & SymbolFlags.Value) === SymbolFlags.Value)) {
+                if (errorLocation &&
+                    (meaning & SymbolFlags.BlockScopedVariable ||
+                     ((meaning & SymbolFlags.Class || meaning & SymbolFlags.Enum) && (meaning & SymbolFlags.Value) === SymbolFlags.Value))) {
                     const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
                     if (exportOrLocalSymbol.flags & SymbolFlags.BlockScopedVariable || exportOrLocalSymbol.flags & SymbolFlags.Class || exportOrLocalSymbol.flags & SymbolFlags.Enum) {
                         checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
@@ -1923,7 +1930,7 @@ namespace ts {
         }
 
         function createTypeofType() {
-            return getUnionType(convertToArray(typeofEQFacts.keys(), getLiteralType));
+            return getUnionType(arrayFrom(typeofEQFacts.keys(), getLiteralType));
         }
 
         // A reserved member name starts with two underscores, but the third character cannot be an underscore
@@ -6312,12 +6319,12 @@ namespace ts {
                     // If a type parameter does not have a default type, or if the default type
                     // is a forward reference, the empty object type is used.
                     for (let i = numTypeArguments; i < numTypeParameters; i++) {
-                        typeArguments[i] = isJavaScript ? anyType : emptyObjectType;
+                        typeArguments[i] = getDefaultTypeArgumentType(isJavaScript);
                     }
                     for (let i = numTypeArguments; i < numTypeParameters; i++) {
                         const mapper = createTypeMapper(typeParameters, typeArguments);
                         const defaultType = getDefaultFromTypeParameter(typeParameters[i]);
-                        typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : isJavaScript ? anyType : emptyObjectType;
+                        typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : getDefaultTypeArgumentType(isJavaScript);
                     }
                 }
             }
@@ -6391,7 +6398,7 @@ namespace ts {
                     undefined;
                 // JS functions get a free rest parameter if they reference `arguments`
                 let hasRestLikeParameter = hasRestParameter(declaration);
-                if (!hasRestLikeParameter && isInJavaScriptFile(declaration) && !hasJSDocParameterTags(declaration) && containsArgumentsReference(declaration)) {
+                if (!hasRestLikeParameter && isInJavaScriptFile(declaration) && containsArgumentsReference(declaration)) {
                     hasRestLikeParameter = true;
                     const syntheticArgsSymbol = createSymbol(SymbolFlags.Variable, "args");
                     syntheticArgsSymbol.type = anyArrayType;
@@ -7967,7 +7974,8 @@ namespace ts {
             };
         }
 
-        function createTypeMapper(sources: Type[], targets: Type[]): TypeMapper {
+        function createTypeMapper(sources: TypeParameter[], targets: Type[]): TypeMapper {
+            Debug.assert(targets === undefined || sources.length === targets.length);
             const mapper: TypeMapper = sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) :
                 sources.length === 2 ? makeBinaryTypeMapper(sources[0], targets ? targets[0] : anyType, sources[1], targets ? targets[1] : anyType) :
                     makeArrayTypeMapper(sources, targets);
@@ -7975,7 +7983,7 @@ namespace ts {
             return mapper;
         }
 
-        function createTypeEraser(sources: Type[]): TypeMapper {
+        function createTypeEraser(sources: TypeParameter[]): TypeMapper {
             return createTypeMapper(sources, /*targets*/ undefined);
         }
 
@@ -8516,7 +8524,7 @@ namespace ts {
                     }
                     else if (isIdentifierTypePredicate(target.typePredicate)) {
                         if (reportErrors) {
-                            errorReporter(Diagnostics.Signature_0_must_have_a_type_predicate, signatureToString(source));
+                            errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
                         }
                         return Ternary.False;
                     }
@@ -10523,12 +10531,8 @@ namespace ts {
                 }
             }
 
-            function inferFromParameterTypes(source: Type, target: Type) {
-                return inferFromTypes(source, target);
-            }
-
             function inferFromSignature(source: Signature, target: Signature) {
-                forEachMatchingParameterType(source, target, inferFromParameterTypes);
+                forEachMatchingParameterType(source, target, inferFromTypes);
 
                 if (source.typePredicate && target.typePredicate && source.typePredicate.kind === target.typePredicate.kind) {
                     inferFromTypes(source.typePredicate.type, target.typePredicate.type);
@@ -10627,7 +10631,7 @@ namespace ts {
                                 context));
                     }
                     else {
-                        inferredType = context.flags & InferenceFlags.AnyDefault ? anyType : emptyObjectType;
+                        inferredType = getDefaultTypeArgumentType(!!(context.flags & InferenceFlags.AnyDefault));
                     }
                 }
                 inference.inferredType = inferredType;
@@ -10643,6 +10647,10 @@ namespace ts {
             return inferredType;
         }
 
+        function getDefaultTypeArgumentType(isInJavaScriptFile: boolean): Type {
+            return isInJavaScriptFile ? anyType : emptyObjectType;
+        }
+
         function getInferredTypes(context: InferenceContext): Type[] {
             const result: Type[] = [];
             for (let i = 0; i < context.inferences.length; i++) {
@@ -12693,12 +12701,6 @@ namespace ts {
                 if (typeNode) {
                     return getTypeFromTypeNode(typeNode);
                 }
-                if (isInJavaScriptFile(declaration)) {
-                    const jsDocType = getTypeForDeclarationFromJSDocComment(declaration);
-                    if (jsDocType) {
-                        return jsDocType;
-                    }
-                }
                 if (declaration.kind === SyntaxKind.Parameter) {
                     const type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
                     if (type) {
@@ -12792,7 +12794,9 @@ namespace ts {
             const args = getEffectiveCallArguments(callTarget);
             const argIndex = indexOf(args, arg);
             if (argIndex >= 0) {
-                const signature = getResolvedOrAnySignature(callTarget);
+                // If we're already in the process of resolving the given signature, don't resolve again as
+                // that could cause infinite recursion. Instead, return anySignature.
+                const signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
                 return getTypeAtPosition(signature, argIndex);
             }
             return undefined;
@@ -13306,6 +13310,7 @@ namespace ts {
             let patternWithComputedProperties = false;
             let hasComputedStringProperty = false;
             let hasComputedNumberProperty = false;
+            const isInJSFile = isInJavaScriptFile(node);
 
             let offset = 0;
             for (let i = 0; i < node.properties.length; i++) {
@@ -13314,6 +13319,11 @@ namespace ts {
                 if (memberDecl.kind === SyntaxKind.PropertyAssignment ||
                     memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||
                     isObjectLiteralMethod(memberDecl)) {
+                    let jsdocType: Type;
+                    if (isInJSFile) {
+                        jsdocType = getTypeForDeclarationFromJSDocComment(memberDecl);
+                    }
+
                     let type: Type;
                     if (memberDecl.kind === SyntaxKind.PropertyAssignment) {
                         type = checkPropertyAssignment(<PropertyAssignment>memberDecl, checkMode);
@@ -13326,6 +13336,11 @@ namespace ts {
                         type = checkExpressionForMutableLocation((<ShorthandPropertyAssignment>memberDecl).name, checkMode);
                     }
 
+                    if (jsdocType) {
+                        checkTypeAssignableTo(type, jsdocType, memberDecl);
+                        type = jsdocType;
+                    }
+
                     typeFlags |= type.flags;
                     const prop = createSymbol(SymbolFlags.Property | member.flags, member.name);
                     if (inDestructuringPattern) {
@@ -14485,7 +14500,7 @@ namespace ts {
         }
 
         function getSuggestionForNonexistentProperty(node: Identifier, containingType: Type): string | undefined {
-            const suggestion = getSpellingSuggestionForName(node.text, getPropertiesOfObjectType(containingType), SymbolFlags.Value);
+            const suggestion = getSpellingSuggestionForName(node.text, getPropertiesOfType(containingType), SymbolFlags.Value);
             return suggestion && suggestion.name;
         }
 
@@ -14956,16 +14971,14 @@ namespace ts {
         }
 
         function inferTypeArguments(node: CallLikeExpression, signature: Signature, args: Expression[], excludeArgument: boolean[], context: InferenceContext): Type[] {
-            const inferences = context.inferences;
-
             // Clear out all the inference results from the last time inferTypeArguments was called on this context
-            for (let i = 0; i < inferences.length; i++) {
+            for (const inference of context.inferences) {
                 // As an optimization, we don't have to clear (and later recompute) inferred types
                 // for type parameters that have already been fixed on the previous call to inferTypeArguments.
                 // It would be just as correct to reset all of them. But then we'd be repeating the same work
                 // for the type parameters that were fixed, namely the work done by getInferredType.
-                if (!inferences[i].isFixed) {
-                    inferences[i].inferredType = undefined;
+                if (!inference.isFixed) {
+                    inference.inferredType = undefined;
                 }
             }
 
@@ -15634,19 +15647,34 @@ namespace ts {
             }
 
             // No signature was applicable. We have already reported the errors for the invalid signature.
-            // If this is a type resolution session, e.g. Language Service, try to get better information that anySignature.
-            // Pick the first candidate that matches the arity. This way we can get a contextual type for cases like:
-            //  declare function f(a: { xa: number; xb: number; });
-            //  f({ |
+            // If this is a type resolution session, e.g. Language Service, try to get better information than anySignature.
+            // Pick the longest signature. This way we can get a contextual type for cases like:
+            //     declare function f(a: { xa: number; xb: number; }, b: number);
+            //     f({ |
+            // Also, use explicitly-supplied type arguments if they are provided, so we can get a contextual signature in cases like:
+            //     declare function f<T>(k: keyof T);
+            //     f<Foo>("
             if (!produceDiagnostics) {
-                for (let candidate of candidates) {
-                    if (hasCorrectArity(node, args, candidate)) {
-                        if (candidate.typeParameters && typeArguments) {
-                            candidate = getSignatureInstantiation(candidate, map(typeArguments, getTypeFromTypeNode));
-                        }
-                        return candidate;
+                Debug.assert(candidates.length > 0); // Else would have exited above.
+                const bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === undefined ? args.length : apparentArgumentCount);
+                const candidate = candidates[bestIndex];
+
+                const { typeParameters } = candidate;
+                if (typeParameters && callLikeExpressionMayHaveTypeArguments(node) && node.typeArguments) {
+                    const typeArguments = node.typeArguments.map(getTypeOfNode);
+                    while (typeArguments.length > typeParameters.length) {
+                        typeArguments.pop();
                     }
+                    while (typeArguments.length < typeParameters.length) {
+                        typeArguments.push(getDefaultTypeArgumentType(isInJavaScriptFile(node)));
+                    }
+
+                    const instantiated = createSignatureInstantiation(candidate, typeArguments);
+                    candidates[bestIndex] = instantiated;
+                    return instantiated;
                 }
+
+                return candidate;
             }
 
             return resolveErrorCall(node);
@@ -15654,7 +15682,8 @@ namespace ts {
             function chooseOverload(candidates: Signature[], relation: Map<RelationComparisonResult>, signatureHelpTrailingComma = false) {
                 candidateForArgumentError = undefined;
                 candidateForTypeArgumentError = undefined;
-                for (const originalCandidate of candidates) {
+                for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+                    const originalCandidate = candidates[candidateIndex];
                     if (!hasCorrectArity(node, args, originalCandidate, signatureHelpTrailingComma)) {
                         continue;
                     }
@@ -15686,6 +15715,7 @@ namespace ts {
                         }
                         const index = excludeArgument ? indexOf(excludeArgument, /*value*/ true) : -1;
                         if (index < 0) {
+                            candidates[candidateIndex] = candidate;
                             return candidate;
                         }
                         excludeArgument[index] = false;
@@ -15697,6 +15727,24 @@ namespace ts {
 
         }
 
+        function getLongestCandidateIndex(candidates: Signature[], argsCount: number): number {
+            let maxParamsIndex = -1;
+            let maxParams = -1;
+
+            for (let i = 0; i < candidates.length; i++) {
+                const candidate = candidates[i];
+                if (candidate.hasRestParameter || candidate.parameters.length >= argsCount) {
+                    return i;
+                }
+                if (candidate.parameters.length > maxParams) {
+                    maxParams = candidate.parameters.length;
+                    maxParamsIndex = i;
+                }
+            }
+
+            return maxParamsIndex;
+        }
+
         function resolveCallExpression(node: CallExpression, candidatesOutArray: Signature[]): Signature {
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
                 const superType = checkSuperExpression(node.expression);
@@ -16011,9 +16059,7 @@ namespace ts {
 
             const callSignatures = elementType && getSignaturesOfType(elementType, SignatureKind.Call);
             if (callSignatures && callSignatures.length > 0) {
-                let callSignature: Signature;
-                callSignature = resolveCall(openingLikeElement, callSignatures, candidatesOutArray);
-                return callSignature;
+                return resolveCall(openingLikeElement, callSignatures, candidatesOutArray);
             }
 
             return undefined;
@@ -16063,12 +16109,6 @@ namespace ts {
             return result;
         }
 
-        function getResolvedOrAnySignature(node: CallLikeExpression) {
-            // If we're already in the process of resolving the given signature, don't resolve again as
-            // that could cause infinite recursion. Instead, return anySignature.
-            return getNodeLinks(node).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(node);
-        }
-
         /**
          * Indicates whether a declaration can be treated as a constructor in a JavaScript
          * file.
@@ -19426,6 +19466,9 @@ namespace ts {
                         case SyntaxKind.ConstructorType:
                             checkUnusedTypeParameters(<FunctionLikeDeclaration>node);
                             break;
+                        case SyntaxKind.TypeAliasDeclaration:
+                            checkUnusedTypeParameters(<TypeAliasDeclaration>node);
+                            break;
                     }
                 }
             }
@@ -19503,7 +19546,7 @@ namespace ts {
             }
         }
 
-        function checkUnusedTypeParameters(node: ClassDeclaration | ClassExpression | FunctionDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction | ConstructorDeclaration | SignatureDeclaration | InterfaceDeclaration) {
+        function checkUnusedTypeParameters(node: ClassDeclaration | ClassExpression | FunctionDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction | ConstructorDeclaration | SignatureDeclaration | InterfaceDeclaration | TypeAliasDeclaration) {
             if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
                 if (node.typeParameters) {
                     // Only report errors on the last declaration for the type parameter container;
@@ -21208,6 +21251,7 @@ namespace ts {
             checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
             checkTypeParameters(node.typeParameters);
             checkSourceElement(node.type);
+            registerForUnusedIdentifiersCheck(node);
         }
 
         function computeEnumMemberValues(node: EnumDeclaration) {
@@ -22452,25 +22496,25 @@ namespace ts {
                 }
 
                 if (entityName.kind === SyntaxKind.Identifier) {
-                    if (isJSXTagName(entityName) && isJsxIntrinsicIdentifier(<Identifier>entityName)) {
+                    if (isJSXTagName(entityName) && isJsxIntrinsicIdentifier(entityName)) {
                         return getIntrinsicTagSymbol(<JsxOpeningLikeElement>entityName.parent);
                     }
 
-                    return resolveEntityName(<Identifier>entityName, SymbolFlags.Value, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
+                    return resolveEntityName(entityName, SymbolFlags.Value, /*ignoreErrors*/ false, /*dontResolveAlias*/ true);
                 }
-                else if (entityName.kind === SyntaxKind.PropertyAccessExpression) {
-                    const symbol = getNodeLinks(entityName).resolvedSymbol;
-                    if (!symbol) {
-                        checkPropertyAccessExpression(<PropertyAccessExpression>entityName);
+                else if (entityName.kind === SyntaxKind.PropertyAccessExpression || entityName.kind === SyntaxKind.QualifiedName) {
+                    const links = getNodeLinks(entityName);
+                    if (links.resolvedSymbol) {
+                        return links.resolvedSymbol;
                     }
-                    return getNodeLinks(entityName).resolvedSymbol;
-                }
-                else if (entityName.kind === SyntaxKind.QualifiedName) {
-                    const symbol = getNodeLinks(entityName).resolvedSymbol;
-                    if (!symbol) {
-                        checkQualifiedName(<QualifiedName>entityName);
+
+                    if (entityName.kind === SyntaxKind.PropertyAccessExpression) {
+                        checkPropertyAccessExpression(entityName);
                     }
-                    return getNodeLinks(entityName).resolvedSymbol;
+                    else {
+                        checkQualifiedName(entityName);
+                    }
+                    return links.resolvedSymbol;
                 }
             }
             else if (isTypeReferenceIdentifier(<EntityName>entityName)) {
@@ -23218,10 +23262,10 @@ namespace ts {
             // this variable and functions that use it are deliberately moved here from the outer scope
             // to avoid scope pollution
             const resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
-            let fileToDirective: FileMap<string>;
+            let fileToDirective: Map<string>;
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
-                fileToDirective = createFileMap<string>();
+                fileToDirective = createMap<string>();
                 resolvedTypeReferenceDirectives.forEach((resolvedDirective, key) => {
                     if (!resolvedDirective) {
                         return;
@@ -23349,7 +23393,7 @@ namespace ts {
                 // check that at least one declaration of top level symbol originates from type declaration file
                 for (const decl of symbol.declarations) {
                     const file = getSourceFileOfNode(decl);
-                    if (fileToDirective.contains(file.path)) {
+                    if (fileToDirective.has(file.path)) {
                         return true;
                     }
                 }
@@ -23618,7 +23662,14 @@ namespace ts {
                         }
                         flags |= ModifierFlags.Export;
                         break;
+                    case SyntaxKind.DefaultKeyword:
+                        const container = node.parent.kind === SyntaxKind.SourceFile ? node.parent : node.parent.parent;
+                        if (container.kind === SyntaxKind.ModuleDeclaration && !isAmbientModule(container)) {
+                            return grammarErrorOnNode(modifier, Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
+                        }
 
+                        flags |= ModifierFlags.Default;
+                        break;
                     case SyntaxKind.DeclareKeyword:
                         if (flags & ModifierFlags.Ambient) {
                             return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");

src/compiler/commandLineParser.ts

@@ -1290,7 +1290,7 @@ namespace ts {
                 case "object":
                     return {};
                 default:
-                    return arrayFrom((<CommandLineOptionOfCustomType>option).type.keys())[0];
+                    return (option as CommandLineOptionOfCustomType).type.keys().next().value;
             }
         }
 
@@ -1992,7 +1992,7 @@ namespace ts {
         }
 
         if (include && include.length > 0) {
-            for (const file of host.readDirectory(basePath, supportedExtensions, exclude, include)) {
+            for (const file of host.readDirectory(basePath, supportedExtensions, exclude, include, /*depth*/ undefined)) {
                 // If we have already included a literal or wildcard path with a
                 // higher priority extension, we should skip this file.
                 //

src/compiler/core.ts

@@ -2,8 +2,9 @@
 /// <reference path="performance.ts" />
 
 namespace ts {
+    export const versionMajorMinor = "2.5";
     /** The version of the TypeScript compiler release */
-    export const version = "2.5.0";
+    export const version = `${versionMajorMinor}.0`;
 }
 
 /* @internal */
@@ -145,7 +146,7 @@ namespace ts {
         };
     }
 
-    export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
+    export function createFileMap<T>(keyMapper: (key: string) => string): FileMap<T> {
         const files = createMap<T>();
         return {
             get,
@@ -169,28 +170,24 @@ namespace ts {
 
         // path should already be well-formed so it does not need to be normalized
         function get(path: Path): T {
-            return files.get(toKey(path));
+            return files.get(keyMapper(path));
         }
 
         function set(path: Path, value: T) {
-            files.set(toKey(path), value);
+            files.set(keyMapper(path), value);
         }
 
         function contains(path: Path) {
-            return files.has(toKey(path));
+            return files.has(keyMapper(path));
         }
 
         function remove(path: Path) {
-            files.delete(toKey(path));
+            files.delete(keyMapper(path));
         }
 
         function clear() {
             files.clear();
         }
-
-        function toKey(path: Path): string {
-            return keyMapper ? keyMapper(path) : path;
-        }
     }
 
     export function toPath(fileName: string, basePath: string, getCanonicalFileName: (path: string) => string): Path {
@@ -999,14 +996,6 @@ namespace ts {
         return result;
     }
 
-    export function convertToArray<T, U>(iterator: Iterator<T>, f: (value: T) => U) {
-        const result: U[] = [];
-        for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-            result.push(f(value));
-        }
-        return result;
-    }
-
     /**
      * Calls `callback` for each entry in the map, returning the first truthy result.
      * Use `map.forEach` instead for normal iteration.
@@ -1101,6 +1090,15 @@ namespace ts {
         return result;
     }
 
+    /**
+     * Creates a set from the elements of an array.
+     *
+     * @param array the array of input elements.
+     */
+    export function arrayToSet<T>(array: T[], makeKey: (value: T) => string): Map<true> {
+        return arrayToMap<T, true>(array, makeKey, () => true);
+    }
+
     export function cloneMap<T>(map: Map<T>) {
         const clone = createMap<T>();
         copyEntries(map, clone);
@@ -2020,7 +2018,7 @@ namespace ts {
         };
     }
 
-    export function matchFiles(path: string, extensions: string[], excludes: string[], includes: string[], useCaseSensitiveFileNames: boolean, currentDirectory: string, getFileSystemEntries: (path: string) => FileSystemEntries): string[] {
+    export function matchFiles(path: string, extensions: string[], excludes: string[], includes: string[], useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries): string[] {
         path = normalizePath(path);
         currentDirectory = normalizePath(currentDirectory);
 
@@ -2037,15 +2035,14 @@ namespace ts {
 
         const comparer = useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive;
         for (const basePath of patterns.basePaths) {
-            visitDirectory(basePath, combinePaths(currentDirectory, basePath));
+            visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
         }
 
         return flatten(results);
 
-        function visitDirectory(path: string, absolutePath: string) {
+        function visitDirectory(path: string, absolutePath: string, depth: number | undefined) {
             let { files, directories } = getFileSystemEntries(path);
             files = files.slice().sort(comparer);
-            directories = directories.slice().sort(comparer);
 
             for (const current of files) {
                 const name = combinePaths(path, current);
@@ -2063,12 +2060,20 @@ namespace ts {
                 }
             }
 
+            if (depth !== undefined) {
+                depth--;
+                if (depth === 0) {
+                    return;
+                }
+            }
+
+            directories = directories.slice().sort(comparer);
             for (const current of directories) {
                 const name = combinePaths(path, current);
                 const absoluteName = combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName);
+                    visitDirectory(name, absoluteName, depth);
                 }
             }
         }
@@ -2118,14 +2123,14 @@ namespace ts {
         return absolute.substring(0, absolute.lastIndexOf(directorySeparator, wildcardOffset));
     }
 
-    export function ensureScriptKind(fileName: string, scriptKind?: ScriptKind): ScriptKind {
+    export function ensureScriptKind(fileName: string, scriptKind: ScriptKind | undefined): ScriptKind {
         // Using scriptKind as a condition handles both:
         // - 'scriptKind' is unspecified and thus it is `undefined`
         // - 'scriptKind' is set and it is `Unknown` (0)
         // If the 'scriptKind' is 'undefined' or 'Unknown' then we attempt
         // to get the ScriptKind from the file name. If it cannot be resolved
         // from the file name then the default 'TS' script kind is returned.
-        return (scriptKind || getScriptKindFromFileName(fileName)) || ScriptKind.TS;
+        return scriptKind || getScriptKindFromFileName(fileName) || ScriptKind.TS;
     }
 
     export function getScriptKindFromFileName(fileName: string): ScriptKind {
@@ -2514,4 +2519,4 @@ namespace ts {
     export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
     }
-}
+}

src/compiler/diagnosticMessages.json

@@ -707,7 +707,7 @@
         "category": "Error",
         "code": 1223
     },
-    "Signature '{0}' must have a type predicate.": {
+    "Signature '{0}' must be a type predicate.": {
         "category": "Error",
         "code": 1224
     },
@@ -3637,7 +3637,7 @@
         "category": "Message",
         "code": 90025
     },
-    
+
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001

src/compiler/moduleNameResolver.ts

@@ -306,7 +306,7 @@ namespace ts {
     }
 
     export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): ModuleResolutionCache {
-        const directoryToModuleNameMap = createFileMap<Map<ResolvedModuleWithFailedLookupLocations>>();
+        const directoryToModuleNameMap = createMap<Map<ResolvedModuleWithFailedLookupLocations>>();
         const moduleNameToDirectoryMap = createMap<PerModuleNameCache>();
 
         return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName };
@@ -334,7 +334,7 @@ namespace ts {
         }
 
         function createPerModuleNameCache(): PerModuleNameCache {
-            const directoryPathMap = createFileMap<ResolvedModuleWithFailedLookupLocations>();
+            const directoryPathMap = createMap<ResolvedModuleWithFailedLookupLocations>();
 
             return { get, set };
 
@@ -356,7 +356,7 @@ namespace ts {
             function set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void {
                 const path = toPath(directory, currentDirectory, getCanonicalFileName);
                 // if entry is already in cache do nothing
-                if (directoryPathMap.contains(path)) {
+                if (directoryPathMap.has(path)) {
                     return;
                 }
                 directoryPathMap.set(path, result);
@@ -370,7 +370,7 @@ namespace ts {
                 let current = path;
                 while (true) {
                     const parent = getDirectoryPath(current);
-                    if (parent === current || directoryPathMap.contains(parent)) {
+                    if (parent === current || directoryPathMap.has(parent)) {
                         break;
                     }
                     directoryPathMap.set(parent, result);
@@ -995,7 +995,7 @@ namespace ts {
     export function getPackageNameFromAtTypesDirectory(mangledName: string): string {
         const withoutAtTypePrefix = removePrefix(mangledName, "@types/");
         if (withoutAtTypePrefix !== mangledName) {
-            return withoutAtTypePrefix.indexOf("__") !== -1 ?
+            return withoutAtTypePrefix.indexOf(mangledScopedPackageSeparator) !== -1 ?
                 "@" + withoutAtTypePrefix.replace(mangledScopedPackageSeparator, ts.directorySeparator) :
                 withoutAtTypePrefix;
         }

src/compiler/program.ts

@@ -382,7 +382,7 @@ namespace ts {
     }
 
     interface DiagnosticCache {
-        perFile?: FileMap<Diagnostic[]>;
+        perFile?: Map<Diagnostic[]>;
         allDiagnostics?: Diagnostic[];
     }
 
@@ -472,7 +472,7 @@ namespace ts {
             resolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile) => loadWithLocalCache(typeReferenceDirectiveNames, containingFile, loader);
         }
 
-        const filesByName = createFileMap<SourceFile>();
+        const filesByName = createMap<SourceFile | undefined>();
         // stores 'filename -> file association' ignoring case
         // used to track cases when two file names differ only in casing
         const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;
@@ -513,6 +513,8 @@ namespace ts {
             }
         }
 
+        const missingFilePaths = arrayFrom(filesByName.keys(), p => <Path>p).filter(p => !filesByName.get(p));
+
         // unconditionally set moduleResolutionCache to undefined to avoid unnecessary leaks
         moduleResolutionCache = undefined;
 
@@ -524,6 +526,7 @@ namespace ts {
             getSourceFile,
             getSourceFileByPath,
             getSourceFiles: () => files,
+            getMissingFilePaths: () => missingFilePaths,
             getCompilerOptions: () => options,
             getSyntacticDiagnostics,
             getOptionsDiagnostics,
@@ -862,6 +865,21 @@ namespace ts {
                 return oldProgram.structureIsReused;
             }
 
+            // If a file has ceased to be missing, then we need to discard some of the old
+            // structure in order to pick it up.
+            // Caution: if the file has created and then deleted between since it was discovered to
+            // be missing, then the corresponding file watcher will have been closed and no new one
+            // will be created until we encounter a change that prevents complete structure reuse.
+            // During this interval, creation of the file will go unnoticed.  We expect this to be
+            // both rare and low-impact.
+            if (oldProgram.getMissingFilePaths().some(missingFilePath => host.fileExists(missingFilePath))) {
+                return oldProgram.structureIsReused = StructureIsReused.SafeModules;
+            }
+
+            for (const p of oldProgram.getMissingFilePaths()) {
+                filesByName.set(p, undefined);
+            }
+
             // update fileName -> file mapping
             for (let i = 0; i < newSourceFiles.length; i++) {
                 filesByName.set(filePaths[i], newSourceFiles[i]);
@@ -1137,7 +1155,6 @@ namespace ts {
                         case SyntaxKind.FunctionExpression:
                         case SyntaxKind.FunctionDeclaration:
                         case SyntaxKind.ArrowFunction:
-                        case SyntaxKind.FunctionDeclaration:
                         case SyntaxKind.VariableDeclaration:
                             // type annotation
                             if ((<FunctionLikeDeclaration | VariableDeclaration | ParameterDeclaration | PropertyDeclaration>parent).type === node) {
@@ -1202,7 +1219,6 @@ namespace ts {
                         case SyntaxKind.FunctionExpression:
                         case SyntaxKind.FunctionDeclaration:
                         case SyntaxKind.ArrowFunction:
-                        case SyntaxKind.FunctionDeclaration:
                             // Check type parameters
                             if (nodes === (<ClassDeclaration | FunctionLikeDeclaration>parent).typeParameters) {
                                 diagnostics.push(createDiagnosticForNodeArray(nodes, Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));
@@ -1316,7 +1332,7 @@ namespace ts {
             const result = getDiagnostics(sourceFile, cancellationToken) || emptyArray;
             if (sourceFile) {
                 if (!cache.perFile) {
-                    cache.perFile = createFileMap<Diagnostic[]>();
+                    cache.perFile = createMap<Diagnostic[]>();
                 }
                 cache.perFile.set(sourceFile.path, result);
             }
@@ -1533,7 +1549,7 @@ namespace ts {
 
         // Get source file from normalized fileName
         function findSourceFile(fileName: string, path: Path, isDefaultLib: boolean, refFile?: SourceFile, refPos?: number, refEnd?: number): SourceFile {
-            if (filesByName.contains(path)) {
+            if (filesByName.has(path)) {
                 const file = filesByName.get(path);
                 // try to check if we've already seen this file but with a different casing in path
                 // NOTE: this only makes sense for case-insensitive file systems
@@ -1953,7 +1969,7 @@ namespace ts {
             // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
             if (!options.noEmit && !options.suppressOutputPathCheck) {
                 const emitHost = getEmitHost();
-                const emitFilesSeen = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
+                const emitFilesSeen = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : key => key);
                 forEachEmittedFile(emitHost, (emitFileNames) => {
                     verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
                     verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);
@@ -1965,7 +1981,7 @@ namespace ts {
                 if (emitFileName) {
                     const emitFilePath = toPath(emitFileName, currentDirectory, getCanonicalFileName);
                     // Report error if the output overwrites input file
-                    if (filesByName.contains(emitFilePath)) {
+                    if (filesByName.has(emitFilePath)) {
                         let chain: DiagnosticMessageChain;
                         if (!options.configFilePath) {
                             // The program is from either an inferred project or an external project

src/compiler/sys.ts

@@ -4,7 +4,13 @@ declare function setTimeout(handler: (...args: any[]) => void, timeout: number):
 declare function clearTimeout(handle: any): void;
 
 namespace ts {
-    export type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
+    export enum FileWatcherEventKind {
+        Created,
+        Changed,
+        Deleted
+    }
+
+    export type FileWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind) => void;
     export type DirectoryWatcherCallback = (fileName: string) => void;
     export interface WatchedFile {
         fileName: string;
@@ -33,7 +39,7 @@ namespace ts {
         getExecutingFilePath(): string;
         getCurrentDirectory(): string;
         getDirectories(path: string): string[];
-        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
+        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[], depth?: number): string[];
         getModifiedTime?(path: string): Date;
         /**
          * This should be cryptographically secure.
@@ -174,7 +180,7 @@ namespace ts {
                         const callbacks = fileWatcherCallbacks.get(fileName);
                         if (callbacks) {
                             for (const fileCallback of callbacks) {
-                                fileCallback(fileName);
+                                fileCallback(fileName, FileWatcherEventKind.Changed);
                             }
                         }
                     }
@@ -281,8 +287,8 @@ namespace ts {
                 }
             }
 
-            function readDirectory(path: string, extensions?: string[], excludes?: string[], includes?: string[]): string[] {
-                return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), getAccessibleFileSystemEntries);
+            function readDirectory(path: string, extensions?: string[], excludes?: string[], includes?: string[], depth?: number): string[] {
+                return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries);
             }
 
             const enum FileSystemEntryKind {
@@ -340,11 +346,22 @@ namespace ts {
                     }
 
                     function fileChanged(curr: any, prev: any) {
-                        if (+curr.mtime <= +prev.mtime) {
+                        const isCurrZero = +curr.mtime === 0;
+                        const isPrevZero = +prev.mtime === 0;
+                        const created = !isCurrZero && isPrevZero;
+                        const deleted = isCurrZero && !isPrevZero;
+
+                        const eventKind = created
+                            ? FileWatcherEventKind.Created
+                            : deleted
+                                ? FileWatcherEventKind.Deleted
+                                : FileWatcherEventKind.Changed;
+
+                        if (eventKind === FileWatcherEventKind.Changed && +curr.mtime <= +prev.mtime) {
                             return;
                         }
 
-                        callback(fileName);
+                        callback(fileName, eventKind);
                     }
                 },
                 watchDirectory: (directoryName, callback, recursive) => {
@@ -475,7 +492,7 @@ namespace ts {
                 getCurrentDirectory: () => ChakraHost.currentDirectory,
                 getDirectories: ChakraHost.getDirectories,
                 getEnvironmentVariable: ChakraHost.getEnvironmentVariable || (() => ""),
-                readDirectory: (path: string, extensions?: string[], excludes?: string[], includes?: string[]) => {
+                readDirectory(path, extensions, excludes, includes, _depth) {
                     const pattern = getFileMatcherPatterns(path, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory);
                     return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern);
                 },

src/compiler/transformers/ts.ts

@@ -3158,7 +3158,7 @@ namespace ts {
                 getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, /*allowComments*/ false, /*allowSourceMaps*/ true),
                 getLocalName(node)
             );
-            setSourceMapRange(expression, createRange(node.name.pos, node.end));
+            setSourceMapRange(expression, createRange(node.name ? node.name.pos : node.pos, node.end));
 
             const statement = createStatement(expression);
             setSourceMapRange(statement, createRange(-1, node.end));

src/compiler/tsc.ts

@@ -285,6 +285,16 @@ namespace ts {
 
             setCachedProgram(compileResult.program);
             reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes));
+
+            const missingPaths = compileResult.program.getMissingFilePaths();
+            missingPaths.forEach(path => {
+                const fileWatcher = sys.watchFile(path, (_fileName, eventKind) => {
+                    if (eventKind === FileWatcherEventKind.Created) {
+                        fileWatcher.close();
+                        startTimerForRecompilation();
+                    }
+                });
+            });
         }
 
         function cachedFileExists(fileName: string): boolean {
@@ -308,7 +318,7 @@ namespace ts {
             const sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
             if (sourceFile && isWatchSet(compilerOptions) && sys.watchFile) {
                 // Attach a file watcher
-                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (_fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
+                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (_fileName, eventKind) => sourceFileChanged(sourceFile, eventKind));
             }
             return sourceFile;
         }
@@ -330,10 +340,10 @@ namespace ts {
         }
 
         // If a source file changes, mark it as unwatched and start the recompilation timer
-        function sourceFileChanged(sourceFile: SourceFile, removed?: boolean) {
+        function sourceFileChanged(sourceFile: SourceFile, eventKind: FileWatcherEventKind) {
             sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
-            if (removed) {
+            if (eventKind === FileWatcherEventKind.Deleted) {
                 unorderedRemoveItem(rootFileNames, sourceFile.fileName);
             }
             startTimerForRecompilation();

src/compiler/types.ts

@@ -2390,7 +2390,7 @@ namespace ts {
     export interface ParseConfigHost {
         useCaseSensitiveFileNames: boolean;
 
-        readDirectory(rootDir: string, extensions: string[], excludes: string[], includes: string[]): string[];
+        readDirectory(rootDir: string, extensions: string[], excludes: string[], includes: string[], depth: number): string[];
 
         /**
          * Gets a value indicating whether the specified path exists and is a file.
@@ -2426,6 +2426,13 @@ namespace ts {
          */
         getSourceFiles(): SourceFile[];
 
+        /**
+         * Get a list of file names that were passed to 'createProgram' or referenced in a
+         * program source file but could not be located.
+         */
+        /* @internal */
+        getMissingFilePaths(): Path[];
+
         /**
          * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
          * the JavaScript and declaration files will be produced for all the files in this program.
@@ -2587,7 +2594,11 @@ namespace ts {
         getAugmentedPropertiesOfType(type: Type): Symbol[];
         getRootSymbols(symbol: Symbol): Symbol[];
         getContextualType(node: Expression): Type | undefined;
-        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature | undefined;
+        /**
+         * returns unknownSignature in the case of an error. Don't know when it returns undefined.
+         * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
+         */
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
         getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
         isImplementationOfOverload(node: FunctionLikeDeclaration): boolean | undefined;
         isUndefinedSymbol(symbol: Symbol): boolean;
@@ -3175,7 +3186,7 @@ namespace ts {
         objectFlags: ObjectFlags;
     }
 
-    /** Class and interface types (TypeFlags.Class and TypeFlags.Interface). */
+    /** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */
     export interface InterfaceType extends ObjectType {
         typeParameters: TypeParameter[];           // Type parameters (undefined if non-generic)
         outerTypeParameters: TypeParameter[];      // Outer type parameters (undefined if none)
@@ -3199,7 +3210,7 @@ namespace ts {
     }
 
     /**
-     * Type references (TypeFlags.Reference). When a class or interface has type parameters or
+     * Type references (ObjectFlags.Reference). When a class or interface has type parameters or
      * a "this" type, references to the class or interface are made using type references. The
      * typeArguments property specifies the types to substitute for the type parameters of the
      * class or interface and optionally includes an extra element that specifies the type to
@@ -3382,8 +3393,8 @@ namespace ts {
     /* @internal */
     export interface TypeMapper {
         (t: TypeParameter): Type;
-        mappedTypes?: Type[];       // Types mapped by this mapper
-        instantiations?: Type[];    // Cache of instantiations created using this type mapper.
+        mappedTypes?: TypeParameter[]; // Types mapped by this mapper
+        instantiations?: Type[];       // Cache of instantiations created using this type mapper.
     }
 
     export const enum InferencePriority {

src/compiler/utilities.ts

@@ -1155,7 +1155,6 @@ namespace ts {
 
     export function isPartOfExpression(node: Node): boolean {
         switch (node.kind) {
-            case SyntaxKind.ThisKeyword:
             case SyntaxKind.SuperKeyword:
             case SyntaxKind.NullKeyword:
             case SyntaxKind.TrueKeyword:
@@ -1224,7 +1223,6 @@ namespace ts {
                     case SyntaxKind.SwitchStatement:
                     case SyntaxKind.CaseClause:
                     case SyntaxKind.ThrowStatement:
-                    case SyntaxKind.SwitchStatement:
                         return (<ExpressionStatement>parent).expression === node;
                     case SyntaxKind.ForStatement:
                         const forStatement = <ForStatement>parent;
@@ -2664,11 +2662,11 @@ namespace ts {
      * Gets the effective type annotation of a variable, parameter, or property. If the node was
      * parsed in a JavaScript file, gets the type annotation from JSDoc.
      */
-    export function getEffectiveTypeAnnotationNode(node: VariableLikeDeclaration): TypeNode {
+    export function getEffectiveTypeAnnotationNode(node: VariableLikeDeclaration): TypeNode | undefined {
         if (node.type) {
             return node.type;
         }
-        if (node.flags & NodeFlags.JavaScriptFile) {
+        if (isInJavaScriptFile(node)) {
             return getJSDocType(node);
         }
     }
@@ -2677,11 +2675,11 @@ namespace ts {
      * Gets the effective return type annotation of a signature. If the node was parsed in a
      * JavaScript file, gets the return type annotation from JSDoc.
      */
-    export function getEffectiveReturnTypeNode(node: SignatureDeclaration): TypeNode {
+    export function getEffectiveReturnTypeNode(node: SignatureDeclaration): TypeNode | undefined {
         if (node.type) {
             return node.type;
         }
-        if (node.flags & NodeFlags.JavaScriptFile) {
+        if (isInJavaScriptFile(node)) {
             return getJSDocReturnType(node);
         }
     }
@@ -4688,6 +4686,11 @@ namespace ts {
 // All node tests in the following list should *not* reference parent pointers so that
 // they may be used with transformations.
 namespace ts {
+    /* @internal */
+    export function isSyntaxList(n: Node): n is SyntaxList {
+        return n.kind === SyntaxKind.SyntaxList;
+    }
+
     /* @internal */
     export function isNode(node: Node) {
         return isNodeKind(node.kind);
@@ -4738,6 +4741,19 @@ namespace ts {
             || kind === SyntaxKind.TemplateTail;
     }
 
+    export function isStringTextContainingNode(node: Node) {
+        switch (node.kind) {
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.TemplateHead:
+            case SyntaxKind.TemplateMiddle:
+            case SyntaxKind.TemplateTail:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     // Identifiers
 
     /* @internal */

src/compiler/visitor.ts

@@ -1148,10 +1148,6 @@ namespace ts {
                 result = reduceNode((<AsExpression>node).type, cbNode, result);
                 break;
 
-            case SyntaxKind.NonNullExpression:
-                result = reduceNode((<NonNullExpression>node).expression, cbNode, result);
-                break;
-
             // Misc
             case SyntaxKind.TemplateSpan:
                 result = reduceNode((<TemplateSpan>node).expression, cbNode, result);

src/harness/harness.ts

@@ -493,7 +493,7 @@ namespace Harness {
         args(): string[];
         getExecutingFilePath(): string;
         exit(exitCode?: number): void;
-        readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[]): string[];
+        readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[], depth?: number): string[];
         tryEnableSourceMapsForHost?(): void;
         getEnvironmentVariable?(name: string): string;
     }
@@ -537,7 +537,7 @@ namespace Harness {
                     ts.sys.tryEnableSourceMapsForHost();
                 }
             }
-            export const readDirectory: typeof IO.readDirectory = (path, extension, exclude, include) => ts.sys.readDirectory(path, extension, exclude, include);
+            export const readDirectory: typeof IO.readDirectory = (path, extension, exclude, include, depth) => ts.sys.readDirectory(path, extension, exclude, include, depth);
 
             export function createDirectory(path: string) {
                 if (!directoryExists(path)) {
@@ -733,12 +733,12 @@ namespace Harness {
                 Http.writeToServerSync(serverRoot + path, "WRITE", contents);
             }
 
-            export function readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[]) {
+            export function readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[], depth?: number) {
                 const fs = new Utils.VirtualFileSystem(path, useCaseSensitiveFileNames());
                 for (const file of listFiles(path)) {
                     fs.addFile(file);
                 }
-                return ts.matchFiles(path, extension, exclude, include, useCaseSensitiveFileNames(), getCurrentDirectory(), path => {
+                return ts.matchFiles(path, extension, exclude, include, useCaseSensitiveFileNames(), getCurrentDirectory(), depth, path => {
                     const entry = fs.traversePath(path);
                     if (entry && entry.isDirectory()) {
                         const directory = <Utils.VirtualDirectory>entry;
@@ -893,13 +893,13 @@ namespace Harness {
             const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
 
             /** Maps a symlink name to a realpath. Used only for exposing `realpath`. */
-            const realPathMap = ts.createFileMap<string>();
+            const realPathMap = ts.createMap<string>();
             /**
              * Maps a file name to a source file.
              * This will have a different SourceFile for every symlink pointing to that file;
              * if the program resolves realpaths then symlink entries will be ignored.
              */
-            const fileMap = ts.createFileMap<ts.SourceFile>();
+            const fileMap = ts.createMap<ts.SourceFile>();
             for (const file of inputFiles) {
                 if (file.content !== undefined) {
                     const fileName = ts.normalizePath(file.unitName);
@@ -975,7 +975,7 @@ namespace Harness {
                 getCanonicalFileName,
                 useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
                 getNewLine: () => newLine,
-                fileExists: fileName => fileMap.contains(toPath(fileName)),
+                fileExists: fileName => fileMap.has(toPath(fileName)),
                 readFile: (fileName: string): string => {
                     const file = fileMap.get(toPath(fileName));
                     if (ts.endsWith(fileName, "json")) {
@@ -999,7 +999,7 @@ namespace Harness {
                 getDirectories: d => {
                     const path = ts.toPath(d, currentDirectory, getCanonicalFileName);
                     const result: string[] = [];
-                    fileMap.forEachValue(key => {
+                    ts.forEachKey(fileMap, key => {
                         if (key.indexOf(path) === 0 && key.lastIndexOf("/") > path.length) {
                             let dirName = key.substr(path.length, key.indexOf("/", path.length + 1) - path.length);
                             if (dirName[0] === "/") {
@@ -1015,12 +1015,12 @@ namespace Harness {
             };
         }
 
-        function mapHasFileInDirectory(directoryPath: ts.Path, map: ts.FileMap<any>): boolean {
+        function mapHasFileInDirectory(directoryPath: ts.Path, map: ts.Map<{}>): boolean {
             if (!map) {
                 return false;
             }
             let exists = false;
-            map.forEachValue(fileName => {
+            ts.forEachKey(map, fileName => {
                 if (!exists && ts.startsWith(fileName, directoryPath) && fileName[directoryPath.length] === "/") {
                     exists = true;
                 }

src/harness/harnessLanguageService.ts

@@ -208,10 +208,11 @@ namespace Harness.LanguageService {
             const script = this.getScriptSnapshot(fileName);
             return script !== undefined;
         }
-        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[] {
+        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[], depth?: number): string[] {
             return ts.matchFiles(path, extensions, exclude, include,
                 /*useCaseSensitiveFileNames*/ false,
                 this.getCurrentDirectory(),
+                depth,
                 (p) => this.virtualFileSystem.getAccessibleFileSystemEntries(p));
         }
         readFile(path: string): string {
@@ -312,9 +313,7 @@ namespace Harness.LanguageService {
         getScriptVersion(fileName: string): string { return this.nativeHost.getScriptVersion(fileName); }
         getLocalizedDiagnosticMessages(): string { return JSON.stringify({}); }
 
-        readDirectory(_rootDir: string, _extension: string): string {
-            return ts.notImplemented();
-        }
+        readDirectory = ts.notImplemented;
         readDirectoryNames = ts.notImplemented;
         readFileNames = ts.notImplemented;
         fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; }
@@ -668,9 +667,7 @@ namespace Harness.LanguageService {
             return ts.sys.getEnvironmentVariable(name);
         }
 
-        readDirectory(_path: string, _extension?: string[], _exclude?: string[], _include?: string[]): string[] {
-            return ts.notImplemented();
-        }
+        readDirectory() { return ts.notImplemented(); }
 
         watchFile(): ts.FileWatcher {
             return { close: ts.noop };

src/harness/loggedIO.ts

@@ -67,6 +67,7 @@ interface IOLog {
         extensions: string[],
         exclude: string[],
         include: string[],
+        depth: number,
         result: string[]
     }[];
 }
@@ -220,10 +221,9 @@ namespace Playback {
             memoize(path => findFileByPath(replayLog.filesRead, path, /*throwFileNotFoundError*/ true).contents));
 
         wrapper.readDirectory = recordReplay(wrapper.readDirectory, underlying)(
-            (path, extensions, exclude, include) => {
-                const result = (<ts.System>underlying).readDirectory(path, extensions, exclude, include);
-                const logEntry = { path, extensions, exclude, include, result };
-                recordLog.directoriesRead.push(logEntry);
+            (path, extensions, exclude, include, depth) => {
+                const result = (<ts.System>underlying).readDirectory(path, extensions, exclude, include, depth);
+                recordLog.directoriesRead.push({ path, extensions, exclude, include, depth, result });
                 return result;
             },
             path => {

src/harness/projectsRunner.ts

@@ -275,8 +275,8 @@ class ProjectRunner extends RunnerBase {
                     : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName);
             }
 
-            function readDirectory(rootDir: string, extension: string[], exclude: string[], include: string[]): string[] {
-                const harnessReadDirectoryResult = Harness.IO.readDirectory(getFileNameInTheProjectTest(rootDir), extension, exclude, include);
+            function readDirectory(rootDir: string, extension: string[], exclude: string[], include: string[], depth: number): string[] {
+                const harnessReadDirectoryResult = Harness.IO.readDirectory(getFileNameInTheProjectTest(rootDir), extension, exclude, include, depth);
                 const result: string[] = [];
                 for (let i = 0; i < harnessReadDirectoryResult.length; i++) {
                     result[i] = ts.getRelativePathToDirectoryOrUrl(testCase.projectRoot, harnessReadDirectoryResult[i],

src/harness/rwcRunner.ts

@@ -22,8 +22,7 @@ namespace RWC {
     }
 
     function isTsConfigFile(file: { path: string }): boolean {
-        const tsConfigFileName = "tsconfig.json";
-        return file.path.substr(file.path.length - tsConfigFileName.length).toLowerCase() === tsConfigFileName;
+        return file.path.indexOf("tsconfig") !== -1 && file.path.indexOf("json") !== -1;
     }
 
     export function runRWCTest(jsonPath: string) {
@@ -213,13 +212,13 @@ namespace RWC {
             it("has the expected errors in generated declaration files", () => {
                 if (compilerOptions.declaration && !compilerResult.errors.length) {
                     Harness.Baseline.runBaseline(`${baseName}.dts.errors.txt`, () => {
-                        const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
-                            inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
-
-                        if (declFileCompilationResult.declResult.errors.length === 0) {
+                        if (compilerResult.errors.length === 0) {
                             return null;
                         }
 
+                        const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
+                            inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
+
                         return Harness.Compiler.minimalDiagnosticsToString(declFileCompilationResult.declResult.errors) +
                             Harness.IO.newLine() + Harness.IO.newLine() +
                             Harness.Compiler.getErrorBaseline(tsconfigFiles.concat(declFileCompilationResult.declInputFiles, declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors);

src/harness/tsconfig.json

@@ -129,6 +129,7 @@
         "./unittests/transform.ts",
         "./unittests/customTransforms.ts",
         "./unittests/textChanges.ts",
-        "./unittests/telemetry.ts"
+        "./unittests/telemetry.ts",
+        "./unittests/programMissingFiles.ts"
     ]
 }

src/harness/unittests/cachingInServerLSHost.ts

@@ -75,7 +75,7 @@ namespace ts {
         const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */ true, /*containingProject*/ undefined);
 
         const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo);
-        project.setCompilerOptions({ module: ts.ModuleKind.AMD } );
+        project.setCompilerOptions({ module: ts.ModuleKind.AMD, noLib: true } );
         return {
             project,
             rootScriptInfo

src/harness/unittests/compileOnSave.ts

@@ -208,7 +208,7 @@ namespace ts.projectSystem {
 
                 file1Consumer1.content = `let y = 10;`;
                 host.reloadFS([moduleFile1, file1Consumer1, file1Consumer2, configFile, libFile]);
-                host.triggerFileWatcherCallback(file1Consumer1.path, /*removed*/ false);
+                host.triggerFileWatcherCallback(file1Consumer1.path, FileWatcherEventKind.Changed);
 
                 session.executeCommand(changeModuleFile1ShapeRequest1);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer2] }]);
@@ -225,7 +225,7 @@ namespace ts.projectSystem {
                 session.executeCommand(changeModuleFile1ShapeRequest1);
                 // Delete file1Consumer2
                 host.reloadFS([moduleFile1, file1Consumer1, configFile, libFile]);
-                host.triggerFileWatcherCallback(file1Consumer2.path, /*removed*/ true);
+                host.triggerFileWatcherCallback(file1Consumer2.path, FileWatcherEventKind.Deleted);
                 sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]);
             });
 
@@ -475,7 +475,7 @@ namespace ts.projectSystem {
 
                 openFilesForSession([referenceFile1], session);
                 host.reloadFS([referenceFile1, configFile]);
-                host.triggerFileWatcherCallback(moduleFile1.path, /*removed*/ true);
+                host.triggerFileWatcherCallback(moduleFile1.path, FileWatcherEventKind.Deleted);
 
                 const request = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: referenceFile1.path });
                 sendAffectedFileRequestAndCheckResult(session, request, [

src/harness/unittests/moduleResolution.ts

@@ -950,8 +950,8 @@ import b = require("./moduleB");
             {
                 const f1 = { name: "/root/src/app.ts" };
                 const f2 = { name: "/root/src/types/lib/typings/lib.d.ts" };
-                const package = { name: "/root/src/types/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
-                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ true, f1, f2, package);
+                const packageFile = { name: "/root/src/types/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
+                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ true, f1, f2, packageFile);
             }
             {
                 const f1 = { name: "/root/src/app.ts" };
@@ -961,8 +961,8 @@ import b = require("./moduleB");
             {
                 const f1 = { name: "/root/src/app.ts" };
                 const f2 = { name: "/root/src/node_modules/lib/typings/lib.d.ts" };
-                const package = { name: "/root/src/node_modules/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
-                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, package);
+                const packageFile = { name: "/root/src/node_modules/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
+                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, packageFile);
             }
             {
                 const f1 = { name: "/root/src/app.ts" };
@@ -972,8 +972,8 @@ import b = require("./moduleB");
             {
                 const f1 = { name: "/root/src/app.ts" };
                 const f2 = { name: "/root/src/node_modules/@types/lib/typings/lib.d.ts" };
-                const package = { name: "/root/src/node_modules/@types/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
-                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, package);
+                const packageFile = { name: "/root/src/node_modules/@types/lib/package.json", content: JSON.stringify({ types: "typings/lib.d.ts" }) };
+                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, packageFile);
             }
         });
         it("Can be resolved from secondary location", () => {
@@ -990,8 +990,8 @@ import b = require("./moduleB");
             {
                 const f1 = { name: "/root/src/app.ts" };
                 const f2 = { name: "/root/node_modules/lib/typings/lib.d.ts" };
-                const package = { name: "/root/node_modules/lib/package.json", content: JSON.stringify({ typings: "typings/lib.d.ts" }) };
-                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, package);
+                const packageFile = { name: "/root/node_modules/lib/package.json", content: JSON.stringify({ typings: "typings/lib.d.ts" }) };
+                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, packageFile);
             }
             {
                 const f1 = { name: "/root/src/app.ts" };
@@ -1001,8 +1001,8 @@ import b = require("./moduleB");
             {
                 const f1 = { name: "/root/src/app.ts" };
                 const f2 = { name: "/root/node_modules/@types/lib/typings/lib.d.ts" };
-                const package = { name: "/root/node_modules/@types/lib/package.json", content: JSON.stringify({ typings: "typings/lib.d.ts" }) };
-                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, package);
+                const packageFile = { name: "/root/node_modules/@types/lib/package.json", content: JSON.stringify({ typings: "typings/lib.d.ts" }) };
+                test(/*typesRoot*/"/root/src/types", /* typeDirective */"lib", /*primary*/ false, f1, f2, packageFile);
             }
         });
         it("Primary resolution overrides secondary resolutions", () => {

src/harness/unittests/programMissingFiles.ts

@@ -0,0 +1,103 @@
+/// <reference path="..\harness.ts" />
+
+namespace ts {
+    describe("Program.getMissingFilePaths", () => {
+
+        const options: CompilerOptions = {
+            noLib: true,
+        };
+
+        const emptyFileName = "empty.ts";
+        const emptyFileRelativePath = "./" + emptyFileName;
+
+        const emptyFile: Harness.Compiler.TestFile = {
+            unitName: emptyFileName,
+            content: ""
+        };
+
+        const referenceFileName = "reference.ts";
+        const referenceFileRelativePath = "./" + referenceFileName;
+
+        const referenceFile: Harness.Compiler.TestFile = {
+            unitName: referenceFileName,
+            content:
+                "/// <reference path=\"d:/imaginary/nonexistent1.ts\"/>\n" + // Absolute
+                "/// <reference path=\"./nonexistent2.ts\"/>\n" + // Relative
+                "/// <reference path=\"nonexistent3.ts\"/>\n" + // Unqualified
+                "/// <reference path=\"nonexistent4\"/>\n"   // No extension
+        };
+
+        const testCompilerHost = Harness.Compiler.createCompilerHost(
+            /*inputFiles*/ [emptyFile, referenceFile],
+            /*writeFile*/ undefined,
+            /*scriptTarget*/ undefined,
+            /*useCaseSensitiveFileNames*/ false,
+            /*currentDirectory*/ "d:\\pretend\\",
+            /*newLineKind*/ NewLineKind.LineFeed,
+            /*libFiles*/ undefined
+        );
+
+        it("handles no missing root files", () => {
+            const program = createProgram([emptyFileRelativePath], options, testCompilerHost);
+            const missing = program.getMissingFilePaths();
+            assert.isDefined(missing);
+            assert.deepEqual(missing, []);
+        });
+
+        it("handles missing root file", () => {
+            const program = createProgram(["./nonexistent.ts"], options, testCompilerHost);
+            const missing = program.getMissingFilePaths();
+            assert.isDefined(missing);
+            assert.deepEqual(missing, ["d:/pretend/nonexistent.ts"]); // Absolute path
+        });
+
+        it("handles multiple missing root files", () => {
+            const program = createProgram(["./nonexistent0.ts", "./nonexistent1.ts"], options, testCompilerHost);
+            const missing = program.getMissingFilePaths().sort();
+            assert.deepEqual(missing, ["d:/pretend/nonexistent0.ts", "d:/pretend/nonexistent1.ts"]);
+        });
+
+        it("handles a mix of present and missing root files", () => {
+            const program = createProgram(["./nonexistent0.ts", emptyFileRelativePath, "./nonexistent1.ts"], options, testCompilerHost);
+            const missing = program.getMissingFilePaths().sort();
+            assert.deepEqual(missing, ["d:/pretend/nonexistent0.ts", "d:/pretend/nonexistent1.ts"]);
+        });
+
+        it("handles repeatedly specified root files", () => {
+            const program = createProgram(["./nonexistent.ts", "./nonexistent.ts"], options, testCompilerHost);
+            const missing = program.getMissingFilePaths();
+            assert.isDefined(missing);
+            assert.deepEqual(missing, ["d:/pretend/nonexistent.ts"]);
+        });
+
+        it("normalizes file paths", () => {
+            const program0 = createProgram(["./nonexistent.ts", "./NONEXISTENT.ts"], options, testCompilerHost);
+            const program1 = createProgram(["./NONEXISTENT.ts", "./nonexistent.ts"], options, testCompilerHost);
+            const missing0 = program0.getMissingFilePaths();
+            const missing1 = program1.getMissingFilePaths();
+            assert.equal(missing0.length, 1);
+            assert.deepEqual(missing0, missing1);
+        });
+
+        it("handles missing triple slash references", () => {
+            const program = createProgram([referenceFileRelativePath], options, testCompilerHost);
+            const missing = program.getMissingFilePaths().sort();
+            assert.isDefined(missing);
+            assert.deepEqual(missing, [
+                // From absolute reference
+                "d:/imaginary/nonexistent1.ts",
+
+                // From relative reference
+                "d:/pretend/nonexistent2.ts",
+
+                // From unqualified reference
+                "d:/pretend/nonexistent3.ts",
+
+                // From no-extension reference
+                "d:/pretend/nonexistent4.d.ts",
+                "d:/pretend/nonexistent4.ts",
+                "d:/pretend/nonexistent4.tsx"
+            ]);
+        });
+    });
+}

src/harness/unittests/projectErrors.ts

@@ -135,7 +135,7 @@ namespace ts.projectSystem {
             }
             // fix config and trigger watcher
             host.reloadFS([file1, file2, correctConfig]);
-            host.triggerFileWatcherCallback(correctConfig.path, /*false*/);
+            host.triggerFileWatcherCallback(correctConfig.path, FileWatcherEventKind.Changed);
             {
                 projectService.checkNumberOfProjects({ configuredProjects: 1 });
                 const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);
@@ -177,7 +177,7 @@ namespace ts.projectSystem {
             }
             // break config and trigger watcher
             host.reloadFS([file1, file2, corruptedConfig]);
-            host.triggerFileWatcherCallback(corruptedConfig.path, /*false*/);
+            host.triggerFileWatcherCallback(corruptedConfig.path, FileWatcherEventKind.Changed);
             {
                 projectService.checkNumberOfProjects({ configuredProjects: 1 });
                 const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);

src/harness/unittests/reuseProgramStructure.ts

@@ -316,6 +316,31 @@ namespace ts {
             assert.isTrue(program_1.structureIsReused === StructureIsReused.Not);
         });
 
+        it("succeeds if missing files remain missing", () => {
+            const options: CompilerOptions = { target, noLib: true };
+
+            const program_1 = newProgram(files, ["a.ts"], options);
+            assert.notDeepEqual(emptyArray, program_1.getMissingFilePaths());
+
+            const program_2 = updateProgram(program_1, ["a.ts"], options, noop);
+            assert.deepEqual(program_1.getMissingFilePaths(), program_2.getMissingFilePaths());
+
+            assert.equal(StructureIsReused.Completely, program_1.structureIsReused);
+        });
+
+        it("fails if missing file is created", () => {
+            const options: CompilerOptions = { target, noLib: true };
+
+            const program_1 = newProgram(files, ["a.ts"], options);
+            assert.notDeepEqual(emptyArray, program_1.getMissingFilePaths());
+
+            const newTexts: NamedSourceText[] = files.concat([{ name: "non-existing-file.ts", text: SourceText.New("", "", `var x = 1`) }]);
+            const program_2 = updateProgram(program_1, ["a.ts"], options, noop, newTexts);
+            assert.deepEqual(emptyArray, program_2.getMissingFilePaths());
+
+            assert.equal(StructureIsReused.SafeModules, program_1.structureIsReused);
+        });
+
         it("resolution cache follows imports", () => {
             (<any>Error).stackTraceLimit = Infinity;
 

src/harness/unittests/session.ts

@@ -19,7 +19,7 @@ namespace ts.server {
         getExecutingFilePath(): string { return void 0; },
         getCurrentDirectory(): string { return void 0; },
         getEnvironmentVariable(): string { return ""; },
-        readDirectory(): string[] { return []; },
+        readDirectory() { return []; },
         exit: noop,
         setTimeout() { return 0; },
         clearTimeout: noop,

src/harness/unittests/textChanges.ts

@@ -367,20 +367,22 @@ namespace M {
                 changeTracker.insertNodeAfter(sourceFile, findChild("M", sourceFile), createTestClass(), { prefix: newLineCharacter });
             });
         }
-        {
-            function findOpenBraceForConstructor(sourceFile: SourceFile) {
-                const classDecl = <ClassDeclaration>sourceFile.statements[0];
-                const constructorDecl = forEach(classDecl.members, m => m.kind === SyntaxKind.Constructor && (<ConstructorDeclaration>m).body && <ConstructorDeclaration>m);
-                return constructorDecl.body.getFirstToken();
-            }
-            function createTestSuperCall() {
-                const superCall = createCall(
-                    createSuper(),
+
+        function findOpenBraceForConstructor(sourceFile: SourceFile) {
+            const classDecl = <ClassDeclaration>sourceFile.statements[0];
+            const constructorDecl = forEach(classDecl.members, m => m.kind === SyntaxKind.Constructor && (<ConstructorDeclaration>m).body && <ConstructorDeclaration>m);
+            return constructorDecl.body.getFirstToken();
+        }
+        function createTestSuperCall() {
+            const superCall = createCall(
+                createSuper(),
                     /*typeArguments*/ undefined,
                     /*argumentsArray*/ emptyArray
-                );
-                return createStatement(superCall);
-            }
+            );
+            return createStatement(superCall);
+        }
+
+        {
             const text1 = `
 class A {
     constructor() {

src/harness/unittests/tsserverProjectSystem.ts

@@ -261,9 +261,9 @@ namespace ts.projectSystem {
         return typeof (<File>s).content === "string";
     }
 
-    export function addFolder(fullPath: string, toPath: (s: string) => Path, fs: FileMap<FSEntry>): Folder {
+    export function addFolder(fullPath: string, toPath: (s: string) => Path, fs: Map<FSEntry>): Folder {
         const path = toPath(fullPath);
-        if (fs.contains(path)) {
+        if (fs.has(path)) {
             Debug.assert(isFolder(fs.get(path)));
             return (<Folder>fs.get(path));
         }
@@ -370,7 +370,7 @@ namespace ts.projectSystem {
 
         private readonly output: string[] = [];
 
-        private fs: ts.FileMap<FSEntry>;
+        private fs: Map<FSEntry>;
         private getCanonicalFileName: (s: string) => string;
         private toPath: (f: string) => Path;
         private timeoutCallbacks = new Callbacks();
@@ -390,7 +390,7 @@ namespace ts.projectSystem {
 
         reloadFS(filesOrFolders: FileOrFolder[]) {
             this.filesOrFolders = filesOrFolders;
-            this.fs = createFileMap<FSEntry>();
+            this.fs = createMap<FSEntry>();
             // always inject safelist file in the list of files
             for (const fileOrFolder of filesOrFolders.concat(safeList)) {
                 const path = this.toPath(fileOrFolder.path);
@@ -408,12 +408,12 @@ namespace ts.projectSystem {
 
         fileExists(s: string) {
             const path = this.toPath(s);
-            return this.fs.contains(path) && isFile(this.fs.get(path));
+            return this.fs.has(path) && isFile(this.fs.get(path));
         }
 
         getFileSize(s: string) {
             const path = this.toPath(s);
-            if (this.fs.contains(path)) {
+            if (this.fs.has(path)) {
                 const entry = this.fs.get(path);
                 if (isFile(entry)) {
                     return entry.fileSize ? entry.fileSize : entry.content.length;
@@ -424,12 +424,12 @@ namespace ts.projectSystem {
 
         directoryExists(s: string) {
             const path = this.toPath(s);
-            return this.fs.contains(path) && isFolder(this.fs.get(path));
+            return this.fs.has(path) && isFolder(this.fs.get(path));
         }
 
         getDirectories(s: string) {
             const path = this.toPath(s);
-            if (!this.fs.contains(path)) {
+            if (!this.fs.has(path)) {
                 return [];
             }
             else {
@@ -438,14 +438,13 @@ namespace ts.projectSystem {
             }
         }
 
-        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[] {
-            const that = this;
-            return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), (dir) => {
+        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[], depth?: number): string[] {
+            return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, (dir) => {
                 const result: FileSystemEntries = {
                     directories: [],
                     files: []
                 };
-                const dirEntry = that.fs.get(that.toPath(dir));
+                const dirEntry = this.fs.get(this.toPath(dir));
                 if (isFolder(dirEntry)) {
                     dirEntry.entries.forEach((entry) => {
                         if (isFolder(entry)) {
@@ -485,12 +484,12 @@ namespace ts.projectSystem {
             }
         }
 
-        triggerFileWatcherCallback(fileName: string, removed?: boolean): void {
+        triggerFileWatcherCallback(fileName: string, eventKind: FileWatcherEventKind): void {
             const path = this.toPath(fileName);
             const callbacks = this.watchedFiles.get(path);
             if (callbacks) {
                 for (const callback of callbacks) {
-                    callback(path, removed);
+                    callback(path, eventKind);
                 }
             }
         }
@@ -771,7 +770,7 @@ namespace ts.projectSystem {
 
             // remove the tsconfig file
             host.reloadFS(filesWithoutConfig);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
 
             checkNumberOfInferredProjects(projectService, 2);
             checkNumberOfConfiguredProjects(projectService, 0);
@@ -928,7 +927,7 @@ namespace ts.projectSystem {
                 "files": ["${commonFile1.path}"]
             }`;
             host.reloadFS(files);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
 
             checkNumberOfConfiguredProjects(projectService, 1);
             checkProjectRootFiles(project, [commonFile1.path]);
@@ -1002,7 +1001,7 @@ namespace ts.projectSystem {
                 "files": ["${file1.path}"]
             }`;
             host.reloadFS(files);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
             checkProjectActualFiles(project, [file1.path, classicModuleFile.path, configFile.path]);
             checkNumberOfInferredProjects(projectService, 1);
         });
@@ -1433,7 +1432,7 @@ namespace ts.projectSystem {
             };
 
             host.reloadFS([file1, modifiedFile2, file3]);
-            host.triggerFileWatcherCallback(modifiedFile2.path, /*removed*/ false);
+            host.triggerFileWatcherCallback(modifiedFile2.path, FileWatcherEventKind.Changed);
 
             checkNumberOfInferredProjects(projectService, 1);
             checkProjectActualFiles(projectService.inferredProjects[0], [file1.path, modifiedFile2.path, file3.path]);
@@ -1465,7 +1464,7 @@ namespace ts.projectSystem {
             checkNumberOfProjects(projectService, { inferredProjects: 1 });
 
             host.reloadFS([file1, file3]);
-            host.triggerFileWatcherCallback(file2.path, /*removed*/ true);
+            host.triggerFileWatcherCallback(file2.path, FileWatcherEventKind.Deleted);
 
             checkNumberOfProjects(projectService, { inferredProjects: 2 });
 
@@ -1663,7 +1662,7 @@ namespace ts.projectSystem {
             };
 
             host.reloadFS([file1, file2, modifiedConfigFile]);
-            host.triggerFileWatcherCallback(configFile.path, /*removed*/ false);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
 
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             checkProjectRootFiles(projectService.configuredProjects[0], [file1.path, file2.path]);
@@ -1696,7 +1695,7 @@ namespace ts.projectSystem {
             };
 
             host.reloadFS([file1, file2, modifiedConfigFile]);
-            host.triggerFileWatcherCallback(configFile.path, /*removed*/ false);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
 
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             checkProjectRootFiles(projectService.configuredProjects[0], [file1.path, file2.path]);
@@ -1776,7 +1775,7 @@ namespace ts.projectSystem {
             checkProjectActualFiles(projectService.configuredProjects[0], [file1.path, file2.path, config.path]);
 
             host.reloadFS([file1, file2]);
-            host.triggerFileWatcherCallback(config.path, /*removed*/ true);
+            host.triggerFileWatcherCallback(config.path, FileWatcherEventKind.Deleted);
 
             checkNumberOfProjects(projectService, { inferredProjects: 2 });
             checkProjectActualFiles(projectService.inferredProjects[0], [file1.path]);
@@ -2028,7 +2027,7 @@ namespace ts.projectSystem {
             projectService.openExternalProject({ projectFileName, options: {}, rootFiles: [{ fileName: file1.path, scriptKind: ScriptKind.JS, hasMixedContent: true }] });
 
             checkNumberOfProjects(projectService, { externalProjects: 1 });
-            checkWatchedFiles(host, []);
+            checkWatchedFiles(host, [libFile.path]); // watching the "missing" lib file
 
             const project = projectService.externalProjects[0];
 
@@ -2258,7 +2257,7 @@ namespace ts.projectSystem {
             assert.isFalse(lastEvent.data.languageServiceEnabled, "Language service state");
 
             host.reloadFS([f1, f2, configWithExclude]);
-            host.triggerFileWatcherCallback(config.path, /*removed*/ false);
+            host.triggerFileWatcherCallback(config.path, FileWatcherEventKind.Changed);
 
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             assert.isTrue(project.languageServiceEnabled, "Language service enabled");
@@ -2492,7 +2491,7 @@ namespace ts.projectSystem {
 
             // rename tsconfig.json back to lib.ts
             host.reloadFS([f1, f2]);
-            host.triggerFileWatcherCallback(tsconfig.path, /*removed*/ true);
+            host.triggerFileWatcherCallback(tsconfig.path, FileWatcherEventKind.Deleted);
             projectService.openExternalProject({
                 projectFileName: projectName,
                 rootFiles: toExternalFiles([f1.path, f2.path]),
@@ -2637,7 +2636,7 @@ namespace ts.projectSystem {
             checkProjectActualFiles(projectService.configuredProjects[0], [libES5.path, app.path, config1.path]);
 
             host.reloadFS([libES5, libES2015Promise, app, config2]);
-            host.triggerFileWatcherCallback(config1.path);
+            host.triggerFileWatcherCallback(config1.path, FileWatcherEventKind.Changed);
 
             projectService.checkNumberOfProjects({ configuredProjects: 1 });
             checkProjectActualFiles(projectService.configuredProjects[0], [libES5.path, libES2015Promise.path, app.path, config2.path]);
@@ -2860,7 +2859,7 @@ namespace ts.projectSystem {
             const moduleFileNewPath = "/a/b/moduleFile1.ts";
             moduleFile.path = moduleFileNewPath;
             host.reloadFS([moduleFile, file1]);
-            host.triggerFileWatcherCallback(moduleFileOldPath);
+            host.triggerFileWatcherCallback(moduleFileOldPath, FileWatcherEventKind.Changed);
             host.triggerDirectoryWatcherCallback("/a/b", moduleFile.path);
             host.runQueuedTimeoutCallbacks();
             diags = <server.protocol.Diagnostic[]>session.executeCommand(getErrRequest).response;
@@ -2868,7 +2867,7 @@ namespace ts.projectSystem {
 
             moduleFile.path = moduleFileOldPath;
             host.reloadFS([moduleFile, file1]);
-            host.triggerFileWatcherCallback(moduleFileNewPath);
+            host.triggerFileWatcherCallback(moduleFileNewPath, FileWatcherEventKind.Changed);
             host.triggerDirectoryWatcherCallback("/a/b", moduleFile.path);
             host.runQueuedTimeoutCallbacks();
 
@@ -2912,7 +2911,7 @@ namespace ts.projectSystem {
             const moduleFileNewPath = "/a/b/moduleFile1.ts";
             moduleFile.path = moduleFileNewPath;
             host.reloadFS([moduleFile, file1, configFile]);
-            host.triggerFileWatcherCallback(moduleFileOldPath);
+            host.triggerFileWatcherCallback(moduleFileOldPath, FileWatcherEventKind.Changed);
             host.triggerDirectoryWatcherCallback("/a/b", moduleFile.path);
             host.runQueuedTimeoutCallbacks();
             diags = <server.protocol.Diagnostic[]>session.executeCommand(getErrRequest).response;
@@ -2920,7 +2919,7 @@ namespace ts.projectSystem {
 
             moduleFile.path = moduleFileOldPath;
             host.reloadFS([moduleFile, file1, configFile]);
-            host.triggerFileWatcherCallback(moduleFileNewPath);
+            host.triggerFileWatcherCallback(moduleFileNewPath, FileWatcherEventKind.Changed);
             host.triggerDirectoryWatcherCallback("/a/b", moduleFile.path);
             host.runQueuedTimeoutCallbacks();
             diags = <server.protocol.Diagnostic[]>session.executeCommand(getErrRequest).response;
@@ -3085,7 +3084,7 @@ namespace ts.projectSystem {
                 }
             }`;
             host.reloadFS([file, configFile]);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
             host.runQueuedTimeoutCallbacks();
             serverEventManager.checkEventCountOfType("configFileDiag", 2);
 
@@ -3093,7 +3092,7 @@ namespace ts.projectSystem {
                 "compilerOptions": {}
             }`;
             host.reloadFS([file, configFile]);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
             host.runQueuedTimeoutCallbacks();
             serverEventManager.checkEventCountOfType("configFileDiag", 3);
         });
@@ -4021,7 +4020,7 @@ namespace ts.projectSystem {
 
             configFile.content = configFileContentWithoutCommentLine;
             host.reloadFS([file, configFile]);
-            host.triggerFileWatcherCallback(configFile.path);
+            host.triggerFileWatcherCallback(configFile.path, FileWatcherEventKind.Changed);
 
             const diagsAfterEdit = session.executeCommand(<server.protocol.SemanticDiagnosticsSyncRequest>{
                 type: "request",

src/harness/unittests/typingsInstaller.ts

@@ -663,16 +663,22 @@ namespace ts.projectSystem {
                 path: "/node_modules/jquery/package.json",
                 content: JSON.stringify({ name: "jquery" })
             };
+            // Should not search deeply in node_modules.
+            const nestedPackage = {
+                path: "/node_modules/jquery/nested/package.json",
+                content: JSON.stringify({ name: "nested" }),
+            };
             const jqueryDTS = {
                 path: "/tmp/node_modules/@types/jquery/index.d.ts",
                 content: ""
             };
-            const host = createServerHost([app, jsconfig, jquery, jqueryPackage]);
+            const host = createServerHost([app, jsconfig, jquery, jqueryPackage, nestedPackage]);
             const installer = new (class extends Installer {
                 constructor() {
-                    super(host, { globalTypingsCacheLocation: "/tmp", typesRegistry: createTypesRegistry("jquery") });
+                    super(host, { globalTypingsCacheLocation: "/tmp", typesRegistry: createTypesRegistry("jquery", "nested") });
                 }
-                installWorker(_requestId: number, _args: string[], _cwd: string, cb: TI.RequestCompletedAction) {
+                installWorker(_requestId: number, args: string[], _cwd: string, cb: TI.RequestCompletedAction) {
+                    assert.deepEqual(args, [`@types/jquery@ts${versionMajorMinor}`]);
                     const installedTypings = ["@types/jquery"];
                     const typingFiles = [jqueryDTS];
                     executeCommand(this, host, installedTypings, typingFiles, cb);
@@ -731,7 +737,7 @@ namespace ts.projectSystem {
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             const p = projectService.configuredProjects[0];
             checkProjectActualFiles(p, [app.path, jsconfig.path]);
-            checkWatchedFiles(host, [jsconfig.path, "/bower_components", "/node_modules"]);
+            checkWatchedFiles(host, [jsconfig.path, "/bower_components", "/node_modules", libFile.path]);
 
             installer.installAll(/*expectedCount*/ 1);
 
@@ -820,7 +826,7 @@ namespace ts.projectSystem {
             installer.checkPendingCommands(/*expectedCount*/ 0);
 
             host.reloadFS([f, fixedPackageJson]);
-            host.triggerFileWatcherCallback(fixedPackageJson.path, /*removed*/ false);
+            host.triggerFileWatcherCallback(fixedPackageJson.path, FileWatcherEventKind.Changed);
             // expected install request
             installer.installAll(/*expectedCount*/ 1);
 
@@ -1058,6 +1064,29 @@ namespace ts.projectSystem {
             assert.deepEqual(result.cachedTypingPaths, [node.path]);
             assert.deepEqual(result.newTypingNames, ["bar"]);
         });
+
+        it("should search only 2 levels deep", () => {
+            const app = {
+                path: "/app.js",
+                content: "",
+            };
+            const a = {
+                path: "/node_modules/a/package.json",
+                content: JSON.stringify({ name: "a" }),
+            };
+            const b = {
+                path: "/node_modules/a/b/package.json",
+                content: JSON.stringify({ name: "b" }),
+            };
+            const host = createServerHost([app, a, b]);
+            const cache = createMap<string>();
+            const result = JsTyping.discoverTypings(host, [app.path], getDirectoryPath(<Path>app.path), /*safeListPath*/ undefined, cache, { enable: true }, /*unresolvedImports*/ []);
+            assert.deepEqual(result, {
+                cachedTypingPaths: [],
+                newTypingNames: ["a"], // But not "b"
+                filesToWatch: ["/bower_components", "/node_modules"],
+            });
+        });
     });
 
     describe("telemetry events", () => {
@@ -1066,7 +1095,7 @@ namespace ts.projectSystem {
                 path: "/a/app.js",
                 content: ""
             };
-            const package = {
+            const packageFile = {
                 path: "/a/package.json",
                 content: JSON.stringify({ dependencies: { "commander": "1.0.0" } })
             };
@@ -1075,7 +1104,7 @@ namespace ts.projectSystem {
                 path: cachePath + "node_modules/@types/commander/index.d.ts",
                 content: "export let x: number"
             };
-            const host = createServerHost([f1, package]);
+            const host = createServerHost([f1, packageFile]);
             let seenTelemetryEvent = false;
             const installer = new (class extends Installer {
                 constructor() {
@@ -1115,7 +1144,7 @@ namespace ts.projectSystem {
                 path: "/a/app.js",
                 content: ""
             };
-            const package = {
+            const packageFile = {
                 path: "/a/package.json",
                 content: JSON.stringify({ dependencies: { "commander": "1.0.0" } })
             };
@@ -1124,7 +1153,7 @@ namespace ts.projectSystem {
                 path: cachePath + "node_modules/@types/commander/index.d.ts",
                 content: "export let x: number"
             };
-            const host = createServerHost([f1, package]);
+            const host = createServerHost([f1, packageFile]);
             let beginEvent: server.BeginInstallTypes;
             let endEvent: server.EndInstallTypes;
             const installer = new (class extends Installer {
@@ -1166,12 +1195,12 @@ namespace ts.projectSystem {
                 path: "/a/app.js",
                 content: ""
             };
-            const package = {
+            const packageFile = {
                 path: "/a/package.json",
                 content: JSON.stringify({ dependencies: { "commander": "1.0.0" } })
             };
             const cachePath = "/a/cache/";
-            const host = createServerHost([f1, package]);
+            const host = createServerHost([f1, packageFile]);
             let beginEvent: server.BeginInstallTypes;
             let endEvent: server.EndInstallTypes;
             const installer = new (class extends Installer {

src/harness/virtualFileSystem.ts

@@ -216,8 +216,8 @@ namespace Utils {
             }
         }
 
-        readDirectory(path: string, extensions: string[], excludes: string[], includes: string[]) {
-            return ts.matchFiles(path, extensions, excludes, includes, this.useCaseSensitiveFileNames, this.currentDirectory, (path: string) => this.getAccessibleFileSystemEntries(path));
+        readDirectory(path: string, extensions: string[], excludes: string[], includes: string[], depth: number) {
+            return ts.matchFiles(path, extensions, excludes, includes, this.useCaseSensitiveFileNames, this.currentDirectory, depth, (path: string) => this.getAccessibleFileSystemEntries(path));
         }
     }
 }

src/lib/es2015.d.ts

@@ -1,8 +1,8 @@
 /// <reference path="lib.es2015.core.d.ts" />
 /// <reference path="lib.es2015.collection.d.ts" />
 /// <reference path="lib.es2015.generator.d.ts" />
-/// <reference path="lib.es2015.iterable.d.ts" />
 /// <reference path="lib.es2015.promise.d.ts" />
+/// <reference path="lib.es2015.iterable.d.ts" />
 /// <reference path="lib.es2015.proxy.d.ts" />
 /// <reference path="lib.es2015.reflect.d.ts" />
 /// <reference path="lib.es2015.symbol.d.ts" />

src/server/builder.ts

@@ -84,13 +84,13 @@ namespace ts.server {
          * NOTE: this field is created on demand and should not be accessed directly.
          * Use 'getFileInfos' instead.
          */
-        private fileInfos_doNotAccessDirectly: FileMap<T>;
+        private fileInfos_doNotAccessDirectly: Map<T>;
 
         constructor(public readonly project: Project, private ctor: { new (scriptInfo: ScriptInfo, project: Project): T }) {
         }
 
         private getFileInfos() {
-            return this.fileInfos_doNotAccessDirectly || (this.fileInfos_doNotAccessDirectly = createFileMap<T>());
+            return this.fileInfos_doNotAccessDirectly || (this.fileInfos_doNotAccessDirectly = createMap<T>());
         }
 
         protected hasFileInfos() {
@@ -117,7 +117,7 @@ namespace ts.server {
         }
 
         protected getFileInfoPaths(): Path[] {
-            return this.getFileInfos().getKeys();
+            return arrayFrom(this.getFileInfos().keys() as Iterator<Path>);
         }
 
         protected setFileInfo(path: Path, info: T) {
@@ -125,11 +125,11 @@ namespace ts.server {
         }
 
         protected removeFileInfo(path: Path) {
-            this.getFileInfos().remove(path);
+            this.getFileInfos().delete(path);
         }
 
         protected forEachFileInfo(action: (fileInfo: T) => any) {
-            this.getFileInfos().forEachValue((_path, value) => action(value));
+            this.getFileInfos().forEach(action);
         }
 
         abstract getFilesAffectedBy(scriptInfo: ScriptInfo): string[];

src/server/editorServices.ts

@@ -343,7 +343,7 @@ namespace ts.server {
         /**
          * Container of all known scripts
          */
-        private readonly filenameToScriptInfo = createFileMap<ScriptInfo>();
+        private readonly filenameToScriptInfo = createMap<ScriptInfo>();
         /**
          * maps external project file name to list of config files that were the part of this project
          */
@@ -568,7 +568,7 @@ namespace ts.server {
                     if (info.containingProjects.length === 0) {
                         // Orphan script info, remove it as we can always reload it on next open
                         info.stopWatcher();
-                        this.filenameToScriptInfo.remove(info.path);
+                        this.filenameToScriptInfo.delete(info.path);
                     }
                     else {
                         // file has been changed which might affect the set of referenced files in projects that include
@@ -588,7 +588,7 @@ namespace ts.server {
             // TODO: handle isOpen = true case
 
             if (!info.isScriptOpen()) {
-                this.filenameToScriptInfo.remove(info.path);
+                this.filenameToScriptInfo.delete(info.path);
                 this.lastDeletedFile = info;
 
                 // capture list of projects since detachAllProjects will wipe out original list
@@ -852,14 +852,13 @@ namespace ts.server {
         }
 
         private deleteOrphanScriptInfoNotInAnyProject() {
-            for (const path of this.filenameToScriptInfo.getKeys()) {
-                const info = this.filenameToScriptInfo.get(path);
+            this.filenameToScriptInfo.forEach(info => {
                 if (!info.isScriptOpen() && info.containingProjects.length === 0) {
                     // if there are not projects that include this script info - delete it
                     info.stopWatcher();
-                    this.filenameToScriptInfo.remove(info.path);
+                    this.filenameToScriptInfo.delete(info.path);
                 }
-            }
+            });
         }
 
         /**

src/server/lsHost.ts

@@ -5,8 +5,8 @@
 namespace ts.server {
     export class LSHost implements ts.LanguageServiceHost, ModuleResolutionHost {
         private compilationSettings: ts.CompilerOptions;
-        private readonly resolvedModuleNames = createFileMap<Map<ResolvedModuleWithFailedLookupLocations>>();
-        private readonly resolvedTypeReferenceDirectives = createFileMap<Map<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
+        private readonly resolvedModuleNames = createMap<Map<ResolvedModuleWithFailedLookupLocations>>();
+        private readonly resolvedTypeReferenceDirectives = createMap<Map<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
         private readonly getCanonicalFileName: (fileName: string) => string;
 
         private filesWithChangedSetOfUnresolvedImports: Path[];
@@ -65,7 +65,7 @@ namespace ts.server {
         private resolveNamesWithLocalCache<T extends { failedLookupLocations: string[] }, R>(
             names: string[],
             containingFile: string,
-            cache: ts.FileMap<Map<T>>,
+            cache: Map<Map<T>>,
             loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost) => T,
             getResult: (s: T) => R,
             getResultFileName: (result: R) => string | undefined,
@@ -210,8 +210,11 @@ namespace ts.server {
             return this.host.resolvePath(path);
         }
 
-        fileExists(path: string): boolean {
-            return this.host.fileExists(path);
+        fileExists(file: string): boolean {
+            // As an optimization, don't hit the disks for files we already know don't exist
+            // (because we're watching for their creation).
+            const path = toPath(file, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            return !this.project.isWatchedMissingFile(path) && this.host.fileExists(file);
         }
 
         readFile(fileName: string): string {
@@ -222,8 +225,8 @@ namespace ts.server {
             return this.host.directoryExists(path);
         }
 
-        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[] {
-            return this.host.readDirectory(path, extensions, exclude, include);
+        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[], depth?: number): string[] {
+            return this.host.readDirectory(path, extensions, exclude, include, depth);
         }
 
         getDirectories(path: string): string[] {
@@ -231,8 +234,8 @@ namespace ts.server {
         }
 
         notifyFileRemoved(info: ScriptInfo) {
-            this.resolvedModuleNames.remove(info.path);
-            this.resolvedTypeReferenceDirectives.remove(info.path);
+            this.resolvedModuleNames.delete(info.path);
+            this.resolvedTypeReferenceDirectives.delete(info.path);
         }
 
         setCompilationSettings(opt: ts.CompilerOptions) {

src/server/project.ts

@@ -58,7 +58,7 @@ namespace ts.server {
     }
 
     export class UnresolvedImportsMap {
-        readonly perFileMap = createFileMap<ReadonlyArray<string>>();
+        readonly perFileMap = createMap<ReadonlyArray<string>>();
         private version = 0;
 
         public clear() {
@@ -71,7 +71,7 @@ namespace ts.server {
         }
 
         public remove(path: Path) {
-            this.perFileMap.remove(path);
+            this.perFileMap.delete(path);
             this.version++;
         }
 
@@ -104,9 +104,10 @@ namespace ts.server {
 
     export abstract class Project {
         private rootFiles: ScriptInfo[] = [];
-        private rootFilesMap: FileMap<ScriptInfo> = createFileMap<ScriptInfo>();
+        private rootFilesMap: Map<ScriptInfo> = createMap<ScriptInfo>();
         private program: ts.Program;
         private externalFiles: SortedReadonlyArray<string>;
+        private missingFilesMap: Map<FileWatcher> = createMap<FileWatcher>();
 
         private cachedUnresolvedImportsPerFile = new UnresolvedImportsMap();
         private lastCachedUnresolvedImportsList: SortedReadonlyArray<string>;
@@ -310,6 +311,10 @@ namespace ts.server {
             this.lsHost.dispose();
             this.lsHost = undefined;
 
+            // Clean up file watchers waiting for missing files
+            this.missingFilesMap.forEach(fileWatcher => fileWatcher.close());
+            this.missingFilesMap = undefined;
+
             // signal language service to release source files acquired from document registry
             this.languageService.dispose();
             this.languageService = undefined;
@@ -453,7 +458,7 @@ namespace ts.server {
         }
 
         isRoot(info: ScriptInfo) {
-            return this.rootFilesMap && this.rootFilesMap.contains(info.path);
+            return this.rootFilesMap && this.rootFilesMap.has(info.path);
         }
 
         // add a root file to project
@@ -586,12 +591,12 @@ namespace ts.server {
             const oldProgram = this.program;
             this.program = this.languageService.getProgram();
 
-            let hasChanges = false;
             // bump up the version if
             // - oldProgram is not set - this is a first time updateGraph is called
             // - newProgram is different from the old program and structure of the old program was not reused.
-            if (!oldProgram || (this.program !== oldProgram && !(oldProgram.structureIsReused & StructureIsReused.Completely))) {
-                hasChanges = true;
+            const hasChanges = !oldProgram || (this.program !== oldProgram && !(oldProgram.structureIsReused & StructureIsReused.Completely));
+
+            if (hasChanges) {
                 if (oldProgram) {
                     for (const f of oldProgram.getSourceFiles()) {
                         if (this.program.getSourceFileByPath(f.path)) {
@@ -604,6 +609,35 @@ namespace ts.server {
                         }
                     }
                 }
+
+                const missingFilePaths = this.program.getMissingFilePaths();
+                const missingFilePathsSet = arrayToSet(missingFilePaths, p => p);
+
+                // Files that are no longer missing (e.g. because they are no longer required)
+                // should no longer be watched.
+                this.missingFilesMap.forEach((fileWatcher, missingFilePath) => {
+                    if (!missingFilePathsSet.has(missingFilePath)) {
+                        this.missingFilesMap.delete(missingFilePath);
+                        fileWatcher.close();
+                    }
+                });
+
+                // Missing files that are not yet watched should be added to the map.
+                for (const missingFilePath of missingFilePaths) {
+                    if (!this.missingFilesMap.has(missingFilePath)) {
+                        const fileWatcher = this.projectService.host.watchFile(missingFilePath, (_filename: string, eventKind: FileWatcherEventKind) => {
+                            if (eventKind === FileWatcherEventKind.Created && this.missingFilesMap.has(missingFilePath)) {
+                                fileWatcher.close();
+                                this.missingFilesMap.delete(missingFilePath);
+
+                                // When a missing file is created, we should update the graph.
+                                this.markAsDirty();
+                                this.updateGraph();
+                            }
+                        });
+                        this.missingFilesMap.set(missingFilePath, fileWatcher);
+                    }
+                }
             }
 
             const oldExternalFiles = this.externalFiles || emptyArray as SortedReadonlyArray<string>;
@@ -626,6 +660,10 @@ namespace ts.server {
             return hasChanges;
         }
 
+        isWatchedMissingFile(path: Path) {
+            return this.missingFilesMap.has(path);
+        }
+
         getScriptInfoLSHost(fileName: string) {
             const scriptInfo = this.projectService.getOrCreateScriptInfo(fileName, /*openedByClient*/ false);
             if (scriptInfo) {
@@ -789,7 +827,7 @@ namespace ts.server {
         // remove a root file from project
         protected removeRoot(info: ScriptInfo): void {
             orderedRemoveItem(this.rootFiles, info);
-            this.rootFilesMap.remove(info.path);
+            this.rootFilesMap.delete(info.path);
         }
     }
 

src/server/server.ts

@@ -35,7 +35,6 @@ namespace ts.server {
     } = require("os");
 
     function getGlobalTypingsCacheLocation() {
-        const versionMajorMinor = ts.version.match(/\d+\.\d+/)[0];
         switch (process.platform) {
             case "win32": {
                 const basePath = process.env.LOCALAPPDATA ||
@@ -524,11 +523,14 @@ namespace ts.server {
 
             fs.stat(watchedFile.fileName, (err: any, stats: any) => {
                 if (err) {
-                    watchedFile.callback(watchedFile.fileName);
+                    watchedFile.callback(watchedFile.fileName, FileWatcherEventKind.Changed);
                 }
                 else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
                     watchedFile.mtime = stats.mtime;
-                    watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
+                    const eventKind = watchedFile.mtime.getTime() === 0
+                        ? FileWatcherEventKind.Deleted
+                        : FileWatcherEventKind.Changed;
+                    watchedFile.callback(watchedFile.fileName, eventKind);
                 }
             });
         }
@@ -560,7 +562,9 @@ namespace ts.server {
             const file: WatchedFile = {
                 fileName,
                 callback,
-                mtime: getModifiedTime(fileName)
+                mtime: sys.fileExists(fileName)
+                    ? getModifiedTime(fileName)
+                    : new Date(0) // Any subsequent modification will occur after this time
             };
 
             watchedFiles.push(file);

src/server/tsconfig.library.json

@@ -2,6 +2,7 @@
     "compilerOptions": {
         "noImplicitAny": true,
         "noImplicitThis": true,
+        "alwaysStrict": true,
         "preserveConstEnums": true,
         "pretty": true,
         "outFile": "../../built/local/tsserverlibrary.js",

src/server/typingsInstaller/typingsInstaller.ts

@@ -434,5 +434,4 @@ namespace ts.server.typingsInstaller {
     export function typingsName(packageName: string): string {
         return `@types/${packageName}@ts${versionMajorMinor}`;
     }
-    const versionMajorMinor = version.split(".").slice(0, 2).join(".");
 }

src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts

@@ -19,9 +19,9 @@ namespace ts.codefix {
             // figure out if the `this` access is actually inside the supercall
             // i.e. super(this.a), since in that case we won't suggest a fix
             if (superCall.expression && superCall.expression.kind === SyntaxKind.CallExpression) {
-                const arguments = (<CallExpression>superCall.expression).arguments;
-                for (let i = 0; i < arguments.length; i++) {
-                    if ((<PropertyAccessExpression>arguments[i]).expression === token) {
+                const expressionArguments = (<CallExpression>superCall.expression).arguments;
+                for (let i = 0; i < expressionArguments.length; i++) {
+                    if ((<PropertyAccessExpression>expressionArguments[i]).expression === token) {
                         return undefined;
                     }
                 }
@@ -46,4 +46,4 @@ namespace ts.codefix {
             }
         }
     });
-}
+}

src/services/completions.ts

@@ -234,7 +234,7 @@ namespace ts.Completions {
         const entries: CompletionEntry[] = [];
         const uniques = createMap<true>();
 
-        typeChecker.getResolvedSignature(argumentInfo.invocation, candidates);
+        typeChecker.getResolvedSignature(argumentInfo.invocation, candidates, argumentInfo.argumentCount);
 
         for (const candidate of candidates) {
             addStringLiteralCompletionsFromType(typeChecker.getParameterType(candidate, argumentInfo.argumentIndex), entries, typeChecker, uniques);

src/services/documentHighlights.ts

@@ -2,7 +2,10 @@
 namespace ts.DocumentHighlights {
     export function getDocumentHighlights(program: Program, cancellationToken: CancellationToken, sourceFile: SourceFile, position: number, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] | undefined {
         const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
-        if (!node) return undefined;
+        // Note that getTouchingWord indicates failure by returning the sourceFile node.
+        if (node === sourceFile) return undefined;
+
+        Debug.assert(node.parent !== undefined);
 
         if (isJsxOpeningElement(node.parent) && node.parent.tagName === node || isJsxClosingElement(node.parent)) {
             // For a JSX element, just highlight the matching tag, not all references.

src/services/documentRegistry.ts

@@ -105,17 +105,17 @@ namespace ts {
     export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory = ""): DocumentRegistry {
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
-        const buckets = createMap<FileMap<DocumentRegistryEntry>>();
+        const buckets = createMap<Map<DocumentRegistryEntry>>();
         const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
 
         function getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey {
             return <DocumentRegistryBucketKey>`_${settings.target}|${settings.module}|${settings.noResolve}|${settings.jsx}|${settings.allowJs}|${settings.baseUrl}|${JSON.stringify(settings.typeRoots)}|${JSON.stringify(settings.rootDirs)}|${JSON.stringify(settings.paths)}`;
         }
 
-        function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
+        function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): Map<DocumentRegistryEntry> {
             let bucket = buckets.get(key);
             if (!bucket && createIfMissing) {
-                buckets.set(key, bucket = createFileMap<DocumentRegistryEntry>());
+                buckets.set(key, bucket = createMap<DocumentRegistryEntry>());
             }
             return bucket;
         }
@@ -124,9 +124,9 @@ namespace ts {
             const bucketInfoArray = arrayFrom(buckets.keys()).filter(name => name && name.charAt(0) === "_").map(name => {
                 const entries = buckets.get(name);
                 const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
-                entries.forEachValue((key, entry) => {
+                entries.forEach((entry, name) => {
                     sourceFiles.push({
-                        name: key,
+                        name,
                         refCount: entry.languageServiceRefCount,
                         references: entry.owners.slice(0)
                     });
@@ -222,7 +222,7 @@ namespace ts {
 
             Debug.assert(entry.languageServiceRefCount >= 0);
             if (entry.languageServiceRefCount === 0) {
-                bucket.remove(path);
+                bucket.delete(path);
             }
         }
 

src/services/formatting/formatting.ts

@@ -97,11 +97,41 @@ namespace ts.formatting {
     }
 
     export function formatOnSemicolon(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[] {
-        return formatOutermostParent(position, SyntaxKind.SemicolonToken, sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnSemicolon);
+        const semicolon = findImmediatelyPrecedingTokenOfKind(position, SyntaxKind.SemicolonToken, sourceFile);
+        return formatNodeLines(findOutermostNodeWithinListLevel(semicolon), sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnSemicolon);
+    }
+
+    export function formatOnOpeningCurly(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[] {
+        const openingCurly = findImmediatelyPrecedingTokenOfKind(position, SyntaxKind.OpenBraceToken, sourceFile);
+        if (!openingCurly) {
+            return [];
+        }
+        const curlyBraceRange = openingCurly.parent;
+        const outermostNode = findOutermostNodeWithinListLevel(curlyBraceRange);
+
+        /**
+         * We limit the span to end at the opening curly to handle the case where
+         * the brace matched to that just typed will be incorrect after further edits.
+         * For example, we could type the opening curly for the following method
+         * body without brace-matching activated:
+         * ```
+         * class C {
+         *     foo()
+         * }
+         * ```
+         * and we wouldn't want to move the closing brace.
+         */
+        const textRange: TextRange = {
+            pos: getLineStartPositionForPosition(outermostNode.getStart(sourceFile), sourceFile),
+            end: position
+        };
+
+        return formatSpan(textRange, sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnOpeningCurlyBrace);
     }
 
     export function formatOnClosingCurly(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[] {
-        return formatOutermostParent(position, SyntaxKind.CloseBraceToken, sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnClosingCurlyBrace);
+        const precedingToken = findImmediatelyPrecedingTokenOfKind(position, SyntaxKind.CloseBraceToken, sourceFile);
+        return formatNodeLines(findOutermostNodeWithinListLevel(precedingToken), sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnClosingCurlyBrace);
     }
 
     export function formatDocument(sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeSettings): TextChange[] {
@@ -121,44 +151,36 @@ namespace ts.formatting {
         return formatSpan(span, sourceFile, options, rulesProvider, FormattingRequestKind.FormatSelection);
     }
 
-    function formatOutermostParent(position: number, expectedLastToken: SyntaxKind, sourceFile: SourceFile, options: FormatCodeSettings, rulesProvider: RulesProvider, requestKind: FormattingRequestKind): TextChange[] {
-        const parent = findOutermostParent(position, expectedLastToken, sourceFile);
-        if (!parent) {
-            return [];
-        }
-        const span = {
-            pos: getLineStartPositionForPosition(parent.getStart(sourceFile), sourceFile),
-            end: parent.end
-        };
-        return formatSpan(span, sourceFile, options, rulesProvider, requestKind);
+    /**
+     * Validating `expectedTokenKind` ensures the token was typed in the context we expect (eg: not a comment).
+     * @param expectedTokenKind The kind of the last token constituting the desired parent node.
+     */
+    function findImmediatelyPrecedingTokenOfKind(end: number, expectedTokenKind: SyntaxKind, sourceFile: SourceFile): Node | undefined {
+        const precedingToken = findPrecedingToken(end, sourceFile);
+
+        return precedingToken && precedingToken.kind === expectedTokenKind && end === precedingToken.getEnd() ?
+            precedingToken :
+            undefined;
     }
 
-    function findOutermostParent(position: number, expectedTokenKind: SyntaxKind, sourceFile: SourceFile): Node {
-        const precedingToken = findPrecedingToken(position, sourceFile);
-
-        // when it is claimed that trigger character was typed at given position
-        // we verify that there is a token with a matching kind whose end is equal to position (because the character was just typed).
-        // If this condition is not hold - then trigger character was typed in some other context,
-        // i.e.in comment and thus should not trigger autoformatting
-        if (!precedingToken ||
-            precedingToken.kind !== expectedTokenKind ||
-            position !== precedingToken.getEnd()) {
-            return undefined;
-        }
-
-        // walk up and search for the parent node that ends at the same position with precedingToken.
-        // for cases like this
-        //
-        // let x = 1;
-        // while (true) {
-        // }
-        // after typing close curly in while statement we want to reformat just the while statement.
-        // However if we just walk upwards searching for the parent that has the same end value -
-        // we'll end up with the whole source file. isListElement allows to stop on the list element level
-        let current = precedingToken;
+    /**
+     * Finds the highest node enclosing `node` at the same list level as `node`
+     * and whose end does not exceed `node.end`.
+     *
+     * Consider typing the following
+     * ```
+     * let x = 1;
+     * while (true) {
+     * }
+     * ```
+     * Upon typing the closing curly, we want to format the entire `while`-statement, but not the preceding
+     * variable declaration.
+     */
+    function findOutermostNodeWithinListLevel(node: Node) {
+        let current = node;
         while (current &&
             current.parent &&
-            current.parent.end === precedingToken.end &&
+            current.parent.end === node.end &&
             !isListElement(current.parent, current)) {
             current = current.parent;
         }
@@ -315,7 +337,7 @@ namespace ts.formatting {
     }
 
     /* @internal */
-    export function formatNode(node: Node, sourceFileLike: SourceFileLike, languageVariant: LanguageVariant, initialIndentation: number, delta: number,  rulesProvider: RulesProvider): TextChange[] {
+    export function formatNodeGivenIndentation(node: Node, sourceFileLike: SourceFileLike, languageVariant: LanguageVariant, initialIndentation: number, delta: number,  rulesProvider: RulesProvider): TextChange[] {
         const range = { pos: 0, end: sourceFileLike.text.length };
         return formatSpanWorker(
             range,
@@ -330,6 +352,19 @@ namespace ts.formatting {
             sourceFileLike);
     }
 
+    function formatNodeLines(node: Node, sourceFile: SourceFile, options: FormatCodeSettings, rulesProvider: RulesProvider, requestKind: FormattingRequestKind): TextChange[] {
+        if (!node) {
+            return [];
+        }
+
+        const span = {
+            pos: getLineStartPositionForPosition(node.getStart(sourceFile), sourceFile),
+            end: node.end
+        };
+
+        return formatSpan(span, sourceFile, options, rulesProvider, requestKind);
+    }
+
     function formatSpan(originalRange: TextRange,
         sourceFile: SourceFile,
         options: FormatCodeSettings,
@@ -1096,7 +1131,7 @@ namespace ts.formatting {
                         return;
                     }
 
-                    // edit should not be applied only if we have one line feed between elements
+                    // edit should not be applied if we have one line feed between elements
                     const lineDelta = currentStartLine - previousStartLine;
                     if (lineDelta !== 1) {
                         recordReplace(previousRange.end, currentRange.pos - previousRange.end, options.newLineCharacter);

src/services/formatting/formattingRequestKind.ts

@@ -7,6 +7,7 @@ namespace ts.formatting {
         FormatSelection,
         FormatOnEnter,
         FormatOnSemicolon,
+        FormatOnOpeningCurlyBrace,
         FormatOnClosingCurlyBrace
     }
 }

src/services/formatting/rules.ts

@@ -290,15 +290,15 @@ namespace ts.formatting {
 
             // Place a space before open brace in a function declaration
             this.FunctionOpenBraceLeftTokenRange = Shared.TokenRange.AnyIncludingMultilineComments;
-            this.SpaceBeforeOpenBraceInFunction = new Rule(RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
+            this.SpaceBeforeOpenBraceInFunction = new Rule(RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
 
             // Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc)
             this.TypeScriptOpenBraceLeftTokenRange = Shared.TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.MultiLineCommentTrivia, SyntaxKind.ClassKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ImportKeyword]);
-            this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new Rule(RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
+            this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new Rule(RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
 
             // Place a space before open brace in a control flow construct
             this.ControlOpenBraceLeftTokenRange = Shared.TokenRange.FromTokens([SyntaxKind.CloseParenToken, SyntaxKind.MultiLineCommentTrivia, SyntaxKind.DoKeyword, SyntaxKind.TryKeyword, SyntaxKind.FinallyKeyword, SyntaxKind.ElseKeyword]);
-            this.SpaceBeforeOpenBraceInControl = new Rule(RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
+            this.SpaceBeforeOpenBraceInControl = new Rule(RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForControlBlocks"), Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
 
             // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
             this.SpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), Rules.IsBraceWrappedContext), RuleAction.Space));
@@ -585,6 +585,10 @@ namespace ts.formatting {
             return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName];
         }
 
+        static isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName: keyof FormatCodeSettings): (context: FormattingContext) => boolean {
+            return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName] || context.TokensAreOnSameLine();
+        }
+
         static IsOptionEnabledOrUndefined(optionName: keyof FormatCodeSettings): (context: FormattingContext) => boolean {
             return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !!context.options[optionName];
         }
@@ -644,25 +648,8 @@ namespace ts.formatting {
             return context.contextNode.kind === SyntaxKind.ConditionalExpression;
         }
 
-        static IsSameLineTokenOrBeforeMultilineBlockContext(context: FormattingContext): boolean {
-            //// This check is mainly used inside SpaceBeforeOpenBraceInControl and SpaceBeforeOpenBraceInFunction.
-            ////
-            //// Ex:
-            //// if (1)     { ....
-            ////      * ) and { are on the same line so apply the rule. Here we don't care whether it's same or multi block context
-            ////
-            //// Ex:
-            //// if (1)
-            //// { ... }
-            ////      * ) and { are on different lines. We only need to format if the block is multiline context. So in this case we don't format.
-            ////
-            //// Ex:
-            //// if (1)
-            //// { ...
-            //// }
-            ////      * ) and { are on different lines. We only need to format if the block is multiline context. So in this case we format.
-
-            return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context);
+        static IsSameLineTokenOrBeforeBlockContext(context: FormattingContext): boolean {
+            return context.TokensAreOnSameLine() || Rules.IsBeforeBlockContext(context);
         }
 
         static IsBraceWrappedContext(context: FormattingContext): boolean {

src/services/jsTyping.ts

@@ -61,17 +61,19 @@ namespace ts.JsTyping {
         unresolvedImports: ReadonlyArray<string>):
         { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } {
 
-        // A typing name to typing file path mapping
-        const inferredTypings = createMap<string>();
-
         if (!typeAcquisition || !typeAcquisition.enable) {
             return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
         }
 
+        // A typing name to typing file path mapping
+        const inferredTypings = createMap<string>();
+
         // Only infer typings for .js and .jsx files
-        fileNames = filter(map(fileNames, normalizePath), f => {
-            const kind = ensureScriptKind(f, getScriptKindFromFileName(f));
-            return kind === ScriptKind.JS || kind === ScriptKind.JSX;
+        fileNames = mapDefined(fileNames, fileName => {
+            const path = normalizePath(fileName);
+            if (hasJavaScriptFileExtension(path)) {
+                return path;
+            }
         });
 
         if (!safeList) {
@@ -80,19 +82,17 @@ namespace ts.JsTyping {
         }
 
         const filesToWatch: string[] = [];
+
+        forEach(typeAcquisition.include, addInferredTyping);
+        const exclude = typeAcquisition.exclude || [];
+
         // Directories to search for package.json, bower.json and other typing information
-        let searchDirs: string[] = [];
-        let exclude: string[] = [];
-
-        mergeTypings(typeAcquisition.include);
-        exclude = typeAcquisition.exclude || [];
-
-        const possibleSearchDirs = map(fileNames, getDirectoryPath);
-        if (projectRootPath) {
-            possibleSearchDirs.push(projectRootPath);
+        const possibleSearchDirs = createMap<true>();
+        for (const f of fileNames) {
+            possibleSearchDirs.set(getDirectoryPath(f), true);
         }
-        searchDirs = deduplicate(possibleSearchDirs);
-        for (const searchDir of searchDirs) {
+        possibleSearchDirs.set(projectRootPath, true);
+        possibleSearchDirs.forEach((_true, searchDir) => {
             const packageJsonPath = combinePaths(searchDir, "package.json");
             getTypingNamesFromJson(packageJsonPath, filesToWatch);
 
@@ -100,11 +100,11 @@ namespace ts.JsTyping {
             getTypingNamesFromJson(bowerJsonPath, filesToWatch);
 
             const bowerComponentsPath = combinePaths(searchDir, "bower_components");
-            getTypingNamesFromPackagesFolder(bowerComponentsPath);
+            getTypingNamesFromPackagesFolder(bowerComponentsPath, filesToWatch);
 
             const nodeModulesPath = combinePaths(searchDir, "node_modules");
-            getTypingNamesFromPackagesFolder(nodeModulesPath);
-        }
+            getTypingNamesFromPackagesFolder(nodeModulesPath, filesToWatch);
+        });
         getTypingNamesFromSourceFileNames(fileNames);
 
         // add typings for unresolved imports
@@ -140,41 +140,33 @@ namespace ts.JsTyping {
         });
         return { cachedTypingPaths, newTypingNames, filesToWatch };
 
-        /**
-         * Merge a given list of typingNames to the inferredTypings map
-         */
-        function mergeTypings(typingNames: ReadonlyArray<string>) {
-            if (!typingNames) {
-                return;
-            }
-
-            for (const typing of typingNames) {
-                if (!inferredTypings.has(typing)) {
-                    inferredTypings.set(typing, undefined);
-                }
+        function addInferredTyping(typingName: string) {
+            if (!inferredTypings.has(typingName)) {
+                inferredTypings.set(typingName, undefined);
             }
         }
 
         /**
          * Get the typing info from common package manager json files like package.json or bower.json
          */
-        function getTypingNamesFromJson(jsonPath: string, filesToWatch: string[]) {
-            if (host.fileExists(jsonPath)) {
-                filesToWatch.push(jsonPath);
+        function getTypingNamesFromJson(jsonPath: string, filesToWatch: Push<string>) {
+            if (!host.fileExists(jsonPath)) {
+                return;
             }
-            const result = readConfigFile(jsonPath, (path: string) => host.readFile(path));
-            const jsonConfig: PackageJson = result.config;
-            if (jsonConfig.dependencies) {
-                mergeTypings(getOwnKeys(jsonConfig.dependencies));
-            }
-            if (jsonConfig.devDependencies) {
-                mergeTypings(getOwnKeys(jsonConfig.devDependencies));
-            }
-            if (jsonConfig.optionalDependencies) {
-                mergeTypings(getOwnKeys(jsonConfig.optionalDependencies));
-            }
-            if (jsonConfig.peerDependencies) {
-                mergeTypings(getOwnKeys(jsonConfig.peerDependencies));
+
+            filesToWatch.push(jsonPath);
+            const jsonConfig: PackageJson = readConfigFile(jsonPath, (path: string) => host.readFile(path)).config;
+            addInferredTypingsFromKeys(jsonConfig.dependencies);
+            addInferredTypingsFromKeys(jsonConfig.devDependencies);
+            addInferredTypingsFromKeys(jsonConfig.optionalDependencies);
+            addInferredTypingsFromKeys(jsonConfig.peerDependencies);
+
+            function addInferredTypingsFromKeys(map: MapLike<string> | undefined): void {
+                for (const key in map) {
+                    if (ts.hasProperty(map, key)) {
+                        addInferredTyping(key);
+                    }
+                }
             }
         }
 
@@ -185,17 +177,22 @@ namespace ts.JsTyping {
          * @param fileNames are the names for source files in the project
          */
         function getTypingNamesFromSourceFileNames(fileNames: string[]) {
-            const jsFileNames = filter(fileNames, hasJavaScriptFileExtension);
-            const inferredTypingNames = map(jsFileNames, f => removeFileExtension(getBaseFileName(f.toLowerCase())));
-            const cleanedTypingNames = map(inferredTypingNames, f => f.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, ""));
-
             if (safeList !== EmptySafeList) {
-                mergeTypings(ts.mapDefined(cleanedTypingNames, f => safeList.get(f)));
+                for (const j of fileNames) {
+                    if (!hasJavaScriptFileExtension(j)) continue;
+
+                    const inferredTypingName = removeFileExtension(getBaseFileName(j.toLowerCase()));
+                    const cleanedTypingName = inferredTypingName.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, "");
+                    const safe = safeList.get(cleanedTypingName);
+                    if (safe !== undefined) {
+                        addInferredTyping(safe);
+                    }
+                }
             }
 
-            const hasJsxFile = forEach(fileNames, f => ensureScriptKind(f, getScriptKindFromFileName(f)) === ScriptKind.JSX);
+            const hasJsxFile = some(fileNames, f => fileExtensionIs(f, Extension.Jsx));
             if (hasJsxFile) {
-                mergeTypings(["react"]);
+                addInferredTyping("react");
             }
         }
 
@@ -203,7 +200,7 @@ namespace ts.JsTyping {
          * Infer typing names from packages folder (ex: node_module, bower_components)
          * @param packagesFolderPath is the path to the packages folder
          */
-        function getTypingNamesFromPackagesFolder(packagesFolderPath: string) {
+        function getTypingNamesFromPackagesFolder(packagesFolderPath: string, filesToWatch: Push<string>) {
             filesToWatch.push(packagesFolderPath);
 
             // Todo: add support for ModuleResolutionHost too
@@ -211,7 +208,7 @@ namespace ts.JsTyping {
                 return;
             }
 
-            const typingNames: string[] = [];
+            // depth of 2, so we access `node_modules/foo` but not `node_modules/foo/bar`
             const fileNames = host.readDirectory(packagesFolderPath, [".json"], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2);
             for (const fileName of fileNames) {
                 const normalizedFileName = normalizePath(fileName);
@@ -240,10 +237,9 @@ namespace ts.JsTyping {
                     inferredTypings.set(packageJson.name, absolutePath);
                 }
                 else {
-                    typingNames.push(packageJson.name);
+                    addInferredTyping(packageJson.name);
                 }
             }
-            mergeTypings(typingNames);
         }
 
     }

src/services/refactors/convertFunctionToEs6Class.ts

@@ -164,12 +164,15 @@ namespace ts.refactor {
                 }
 
                 switch (assignmentBinaryExpression.right.kind) {
-                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.FunctionExpression: {
                         const functionExpression = assignmentBinaryExpression.right as FunctionExpression;
-                        return createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
+                        const method = createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
                             /*typeParameters*/ undefined, functionExpression.parameters, /*type*/ undefined, functionExpression.body);
+                        copyComments(assignmentBinaryExpression, method);
+                        return method;
+                    }
 
-                    case SyntaxKind.ArrowFunction:
+                    case SyntaxKind.ArrowFunction: {
                         const arrowFunction = assignmentBinaryExpression.right as ArrowFunction;
                         const arrowFunctionBody = arrowFunction.body;
                         let bodyBlock: Block;
@@ -183,20 +186,42 @@ namespace ts.refactor {
                             const expression = arrowFunctionBody as Expression;
                             bodyBlock = createBlock([createReturn(expression)]);
                         }
-                        return createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
+                        const method = createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
                             /*typeParameters*/ undefined, arrowFunction.parameters, /*type*/ undefined, bodyBlock);
+                        copyComments(assignmentBinaryExpression, method);
+                        return method;
+                    }
 
-                    default:
+                    default: {
                         // Don't try to declare members in JavaScript files
                         if (isSourceFileJavaScript(sourceFile)) {
                             return;
                         }
-                        return createProperty(/*decorators*/ undefined, modifiers, memberDeclaration.name, /*questionToken*/ undefined,
+                        const prop = createProperty(/*decorators*/ undefined, modifiers, memberDeclaration.name, /*questionToken*/ undefined,
                             /*type*/ undefined, assignmentBinaryExpression.right);
+                        copyComments(assignmentBinaryExpression.parent, prop);
+                        return prop;
+                    }
                 }
             }
         }
 
+        function copyComments(sourceNode: Node, targetNode: Node) {
+            forEachLeadingCommentRange(sourceFile.text, sourceNode.pos, (pos, end, kind, htnl) => {
+                if (kind === SyntaxKind.MultiLineCommentTrivia) {
+                    // Remove leading /*
+                    pos += 2;
+                    // Remove trailing */
+                    end -= 2;
+                }
+                else {
+                    // Remove leading //
+                    pos += 2;
+                }
+                addSyntheticLeadingComment(targetNode, kind, sourceFile.text.slice(pos, end), htnl);
+            });
+        }
+
         function createClassFromVariableDeclaration(node: VariableDeclaration): ClassDeclaration {
             const initializer = node.initializer as FunctionExpression;
             if (!initializer || initializer.kind !== SyntaxKind.FunctionExpression) {
@@ -212,8 +237,10 @@ namespace ts.refactor {
                 memberElements.unshift(createConstructor(/*decorators*/ undefined, /*modifiers*/ undefined, initializer.parameters, initializer.body));
             }
 
-            return createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
+            const cls = createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
                 /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements);
+            // Don't call copyComments here because we'll already leave them in place
+            return cls;
         }
 
         function createClassFromFunctionDeclaration(node: FunctionDeclaration): ClassDeclaration {
@@ -221,8 +248,11 @@ namespace ts.refactor {
             if (node.body) {
                 memberElements.unshift(createConstructor(/*decorators*/ undefined, /*modifiers*/ undefined, node.parameters, node.body));
             }
-            return createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
+
+            const cls = createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
                 /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements);
+            // Don't call copyComments here because we'll already leave them in place
+            return cls;
         }
     }
 }

src/services/services.ts

@@ -657,7 +657,6 @@ namespace ts {
                     case SyntaxKind.ImportEqualsDeclaration:
                     case SyntaxKind.ExportSpecifier:
                     case SyntaxKind.ImportSpecifier:
-                    case SyntaxKind.ImportEqualsDeclaration:
                     case SyntaxKind.ImportClause:
                     case SyntaxKind.NamespaceImport:
                     case SyntaxKind.GetAccessor:
@@ -818,14 +817,14 @@ namespace ts {
     // at each language service public entry point, since we don't know when
     // the set of scripts handled by the host changes.
     class HostCache {
-        private fileNameToEntry: FileMap<HostFileInformation>;
+        private fileNameToEntry: Map<HostFileInformation>;
         private _compilationSettings: CompilerOptions;
         private currentDirectory: string;
 
         constructor(private host: LanguageServiceHost, getCanonicalFileName: (fileName: string) => string) {
             // script id => script index
             this.currentDirectory = host.getCurrentDirectory();
-            this.fileNameToEntry = createFileMap<HostFileInformation>();
+            this.fileNameToEntry = createMap<HostFileInformation>();
 
             // Initialize the list with the root file names
             const rootFileNames = host.getScriptFileNames();
@@ -862,7 +861,7 @@ namespace ts {
         }
 
         public containsEntryByPath(path: Path): boolean {
-            return this.fileNameToEntry.contains(path);
+            return this.fileNameToEntry.has(path);
         }
 
         public getOrCreateEntryByPath(fileName: string, path: Path): HostFileInformation {
@@ -874,7 +873,7 @@ namespace ts {
         public getRootFileNames(): string[] {
             const fileNames: string[] = [];
 
-            this.fileNameToEntry.forEachValue((_path, value) => {
+            this.fileNameToEntry.forEach(value => {
                 if (value) {
                     fileNames.push(value.hostFileName);
                 }
@@ -1763,8 +1762,10 @@ namespace ts {
         function getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[] {
             const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
             const settings = toEditorSettings(options);
-
-            if (key === "}") {
+            if (key === "{") {
+                return formatting.formatOnOpeningCurly(position, sourceFile, getRuleProvider(settings), settings);
+            }
+            else if (key === "}") {
                 return formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(settings), settings);
             }
             else if (key === ";") {

src/services/shims.ts

@@ -467,7 +467,7 @@ namespace ts {
         }
     }
 
-    export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost {
+    export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost, JsTyping.TypingResolutionHost {
 
         public directoryExists: (directoryName: string) => boolean;
         public realpath: (path: string) => string;
@@ -484,33 +484,17 @@ namespace ts {
         }
 
         public readDirectory(rootDir: string, extensions: string[], exclude: string[], include: string[], depth?: number): string[] {
-            // Wrap the API changes for 2.0 release. This try/catch
-            // should be removed once TypeScript 2.0 has shipped.
-            try {
-                const pattern = getFileMatcherPatterns(rootDir, exclude, include,
-                    this.shimHost.useCaseSensitiveFileNames(), this.shimHost.getCurrentDirectory());
-                return JSON.parse(this.shimHost.readDirectory(
-                    rootDir,
-                    JSON.stringify(extensions),
-                    JSON.stringify(pattern.basePaths),
-                    pattern.excludePattern,
-                    pattern.includeFilePattern,
-                    pattern.includeDirectoryPattern,
-                    depth
-                ));
-            }
-            catch (e) {
-                const results: string[] = [];
-                for (const extension of extensions) {
-                    for (const file of this.readDirectoryFallback(rootDir, extension, exclude))
-                    {
-                        if (!contains(results, file)) {
-                            results.push(file);
-                        }
-                    }
-                }
-                return results;
-            }
+            const pattern = getFileMatcherPatterns(rootDir, exclude, include,
+                this.shimHost.useCaseSensitiveFileNames(), this.shimHost.getCurrentDirectory());
+            return JSON.parse(this.shimHost.readDirectory(
+                rootDir,
+                JSON.stringify(extensions),
+                JSON.stringify(pattern.basePaths),
+                pattern.excludePattern,
+                pattern.includeFilePattern,
+                pattern.includeDirectoryPattern,
+                depth
+            ));
         }
 
         public fileExists(fileName: string): boolean {
@@ -521,10 +505,6 @@ namespace ts {
             return this.shimHost.readFile(fileName);
         }
 
-        private readDirectoryFallback(rootDir: string, extension: string, exclude: string[]) {
-            return JSON.parse(this.shimHost.readDirectory(rootDir, extension, JSON.stringify(exclude)));
-        }
-
         public getDirectories(path: string): string[] {
             return JSON.parse(this.shimHost.getDirectories(path));
         }

src/services/signatureHelp.ts

@@ -15,6 +15,7 @@ namespace ts.SignatureHelp {
         invocation: CallLikeExpression;
         argumentsSpan: TextSpan;
         argumentIndex?: number;
+        /** argumentCount is the *apparent* number of arguments. */
         argumentCount: number;
     }
 
@@ -29,17 +30,14 @@ namespace ts.SignatureHelp {
         }
 
         const argumentInfo = getContainingArgumentInfo(startingToken, position, sourceFile);
+        if (!argumentInfo) return undefined;
 
         cancellationToken.throwIfCancellationRequested();
 
         // Semantic filtering of signature help
-        if (!argumentInfo) {
-            return undefined;
-        }
-
         const call = argumentInfo.invocation;
-        const candidates = <Signature[]>[];
-        const resolvedSignature = typeChecker.getResolvedSignature(call, candidates);
+        const candidates: Signature[] = [];
+        const resolvedSignature = typeChecker.getResolvedSignature(call, candidates, argumentInfo.argumentCount);
         cancellationToken.throwIfCancellationRequested();
 
         if (!candidates.length) {
@@ -101,7 +99,10 @@ namespace ts.SignatureHelp {
      */
     export function getImmediatelyContainingArgumentInfo(node: Node, position: number, sourceFile: SourceFile): ArgumentListInfo {
         if (isCallOrNewExpression(node.parent)) {
-            const callExpression = <CallExpression>node.parent;
+            const invocation = node.parent;
+            let list: Node;
+            let argumentIndex: number;
+
             // There are 3 cases to handle:
             //   1. The token introduces a list, and should begin a signature help session
             //   2. The token is either not associated with a list, or ends a list, so the session should end
@@ -116,48 +117,30 @@ namespace ts.SignatureHelp {
             //    Case 3:
             //          foo<T#, U#>(a#, #b#) -> The token is buried inside a list, and should give signature help
             // Find out if 'node' is an argument, a type argument, or neither
-            if (node.kind === SyntaxKind.LessThanToken ||
-                node.kind === SyntaxKind.OpenParenToken) {
+            if (node.kind === SyntaxKind.LessThanToken || node.kind === SyntaxKind.OpenParenToken) {
                 // Find the list that starts right *after* the < or ( token.
                 // If the user has just opened a list, consider this item 0.
-                const list = getChildListThatStartsWithOpenerToken(callExpression, node, sourceFile);
-                const isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos;
+                list = getChildListThatStartsWithOpenerToken(invocation, node, sourceFile);
                 Debug.assert(list !== undefined);
-                return {
-                    kind: isTypeArgList ? ArgumentListKind.TypeArguments : ArgumentListKind.CallArguments,
-                    invocation: callExpression,
-                    argumentsSpan: getApplicableSpanForArguments(list, sourceFile),
-                    argumentIndex: 0,
-                    argumentCount: getArgumentCount(list)
-                };
+                argumentIndex = 0;
+            }
+            else {
+                // findListItemInfo can return undefined if we are not in parent's argument list
+                // or type argument list. This includes cases where the cursor is:
+                //   - To the right of the closing parenthesis, non-substitution template, or template tail.
+                //   - Between the type arguments and the arguments (greater than token)
+                //   - On the target of the call (parent.func)
+                //   - On the 'new' keyword in a 'new' expression
+                list = findContainingList(node);
+                if (!list) return undefined;
+                argumentIndex = getArgumentIndex(list, node);
             }
 
-            // findListItemInfo can return undefined if we are not in parent's argument list
-            // or type argument list. This includes cases where the cursor is:
-            //   - To the right of the closing parenthesis, non-substitution template, or template tail.
-            //   - Between the type arguments and the arguments (greater than token)
-            //   - On the target of the call (parent.func)
-            //   - On the 'new' keyword in a 'new' expression
-            const listItemInfo = findListItemInfo(node);
-            if (listItemInfo) {
-                const list = listItemInfo.list;
-                const isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos;
-
-                const argumentIndex = getArgumentIndex(list, node);
-                const argumentCount = getArgumentCount(list);
-
-                Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount,
-                    `argumentCount < argumentIndex, ${argumentCount} < ${argumentIndex}`);
-
-                return {
-                    kind: isTypeArgList ? ArgumentListKind.TypeArguments : ArgumentListKind.CallArguments,
-                    invocation: callExpression,
-                    argumentsSpan: getApplicableSpanForArguments(list, sourceFile),
-                    argumentIndex: argumentIndex,
-                    argumentCount: argumentCount
-                };
-            }
-            return undefined;
+            const kind = invocation.typeArguments && invocation.typeArguments.pos === list.pos ? ArgumentListKind.TypeArguments : ArgumentListKind.CallArguments;
+            const argumentCount = getArgumentCount(list);
+            Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, `argumentCount < argumentIndex, ${argumentCount} < ${argumentIndex}`);
+            const argumentsSpan = getApplicableSpanForArguments(list, sourceFile);
+            return { kind, invocation, argumentsSpan, argumentIndex, argumentCount };
         }
         else if (node.kind === SyntaxKind.NoSubstitutionTemplateLiteral && node.parent.kind === SyntaxKind.TaggedTemplateExpression) {
             // Check if we're actually inside the template;
@@ -294,8 +277,8 @@ namespace ts.SignatureHelp {
             kind: ArgumentListKind.TaggedTemplateArguments,
             invocation: tagExpression,
             argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression, sourceFile),
-            argumentIndex: argumentIndex,
-            argumentCount: argumentCount
+            argumentIndex,
+            argumentCount
         };
     }
 
@@ -367,38 +350,10 @@ namespace ts.SignatureHelp {
         return children[indexOfOpenerToken + 1];
     }
 
-    /**
-     * The selectedItemIndex could be negative for several reasons.
-     *     1. There are too many arguments for all of the overloads
-     *     2. None of the overloads were type compatible
-     * The solution here is to try to pick the best overload by picking
-     * either the first one that has an appropriate number of parameters,
-     * or the one with the most parameters.
-     */
-    function selectBestInvalidOverloadIndex(candidates: Signature[], argumentCount: number): number {
-        let maxParamsSignatureIndex = -1;
-        let maxParams = -1;
-        for (let i = 0; i < candidates.length; i++) {
-            const candidate = candidates[i];
-
-            if (candidate.hasRestParameter || candidate.parameters.length >= argumentCount) {
-                return i;
-            }
-
-            if (candidate.parameters.length > maxParams) {
-                maxParams = candidate.parameters.length;
-                maxParamsSignatureIndex = i;
-            }
-        }
-
-        return maxParamsSignatureIndex;
-    }
-
-    function createSignatureHelpItems(candidates: Signature[], bestSignature: Signature, argumentListInfo: ArgumentListInfo, typeChecker: TypeChecker): SignatureHelpItems {
-        const applicableSpan = argumentListInfo.argumentsSpan;
+    function createSignatureHelpItems(candidates: Signature[], resolvedSignature: Signature, argumentListInfo: ArgumentListInfo, typeChecker: TypeChecker): SignatureHelpItems {
+        const { argumentCount, argumentsSpan: applicableSpan, invocation, argumentIndex } = argumentListInfo;
         const isTypeParameterList = argumentListInfo.kind === ArgumentListKind.TypeArguments;
 
-        const invocation = argumentListInfo.invocation;
         const callTarget = getInvokedExpression(invocation);
         const callTargetSymbol = typeChecker.getSymbolAtLocation(callTarget);
         const callTargetDisplayParts = callTargetSymbol && symbolToDisplayParts(typeChecker, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined);
@@ -415,7 +370,8 @@ namespace ts.SignatureHelp {
             if (isTypeParameterList) {
                 isVariadic = false; // type parameter lists are not variadic
                 prefixDisplayParts.push(punctuationPart(SyntaxKind.LessThanToken));
-                const typeParameters = candidateSignature.typeParameters;
+                // Use `.mapper` to ensure we get the generic type arguments even if this is an instantiated version of the signature.
+                const typeParameters = candidateSignature.mapper ? candidateSignature.mapper.mappedTypes : candidateSignature.typeParameters;
                 signatureHelpParameters = typeParameters && typeParameters.length > 0 ? map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray;
                 suffixDisplayParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
                 const parameterParts = mapToDisplayParts(writer =>
@@ -429,8 +385,7 @@ namespace ts.SignatureHelp {
                 addRange(prefixDisplayParts, typeParameterParts);
                 prefixDisplayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
 
-                const parameters = candidateSignature.parameters;
-                signatureHelpParameters = parameters.length > 0 ? map(parameters, createSignatureHelpParameterForParameter) : emptyArray;
+                signatureHelpParameters = map(candidateSignature.parameters, createSignatureHelpParameterForParameter);
                 suffixDisplayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
             }
 
@@ -449,25 +404,12 @@ namespace ts.SignatureHelp {
             };
         });
 
-        const argumentIndex = argumentListInfo.argumentIndex;
-
-        // argumentCount is the *apparent* number of arguments.
-        const argumentCount = argumentListInfo.argumentCount;
-
-        let selectedItemIndex = candidates.indexOf(bestSignature);
-        if (selectedItemIndex < 0) {
-            selectedItemIndex = selectBestInvalidOverloadIndex(candidates, argumentCount);
-        }
-
         Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, `argumentCount < argumentIndex, ${argumentCount} < ${argumentIndex}`);
 
-        return {
-            items,
-            applicableSpan,
-            selectedItemIndex,
-            argumentIndex,
-            argumentCount
-        };
+        const selectedItemIndex = candidates.indexOf(resolvedSignature);
+        Debug.assert(selectedItemIndex !== -1); // If candidates is non-empty it should always include bestSignature. We check for an empty candidates before calling this function.
+
+        return { items, applicableSpan, selectedItemIndex, argumentIndex, argumentCount };
 
         function createSignatureHelpParameterForParameter(parameter: Symbol): SignatureHelpParameter {
             const displayParts = mapToDisplayParts(writer =>

src/services/textChanges.ts

@@ -415,7 +415,7 @@ namespace ts.textChanges {
         }
 
         public getChanges(): FileTextChanges[] {
-            const changesPerFile = createFileMap<Change[]>();
+            const changesPerFile = createMap<Change[]>();
             // group changes per file
             for (const c of this.changes) {
                 let changesInFile = changesPerFile.get(c.sourceFile.path);
@@ -426,8 +426,7 @@ namespace ts.textChanges {
             }
             // convert changes
             const fileChangesList: FileTextChanges[] = [];
-            changesPerFile.forEachValue(path => {
-                const changesInFile = changesPerFile.get(path);
+            changesPerFile.forEach(changesInFile => {
                 const sourceFile = changesInFile[0].sourceFile;
                 const fileTextChanges: FileTextChanges = { fileName: sourceFile.fileName, textChanges: [] };
                 for (const c of ChangeTracker.normalize(changesInFile)) {
@@ -512,7 +511,7 @@ namespace ts.textChanges {
             lineMap,
             getLineAndCharacterOfPosition: pos => computeLineAndCharacterOfPosition(lineMap, pos)
         };
-        const changes = formatting.formatNode(nonFormattedText.node, file, sourceFile.languageVariant, initialIndentation, delta, rulesProvider);
+        const changes = formatting.formatNodeGivenIndentation(nonFormattedText.node, file, sourceFile.languageVariant, initialIndentation, delta, rulesProvider);
         return applyChanges(nonFormattedText.text, changes);
     }
 

src/services/types.ts

@@ -163,7 +163,7 @@ namespace ts {
          * LS host can optionally implement these methods to support completions for module specifiers.
          * Without these methods, only completions for ambient modules will be provided.
          */
-        readDirectory?(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
+        readDirectory?(path: string, extensions?: string[], exclude?: string[], include?: string[], depth?: number): string[];
         readFile?(path: string, encoding?: string): string;
         fileExists?(path: string): boolean;
 

src/services/utilities.ts

@@ -275,6 +275,13 @@ namespace ts {
     }
 
     export function getContainerNode(node: Node): Declaration {
+        if (node.kind === SyntaxKind.JSDocTypedefTag) {
+            // This doesn't just apply to the node immediately under the comment, but to everything in its parent's scope.
+            // node.parent = the JSDoc comment, node.parent.parent = the node having the comment.
+            // Then we get parent again in the loop.
+            node = node.parent.parent;
+        }
+
         while (true) {
             node = node.parent;
             if (!node) {
@@ -588,14 +595,14 @@ namespace ts {
         return forEach(n.getChildren(sourceFile), c => c.kind === kind && c);
     }
 
-    export function findContainingList(node: Node): Node {
+    export function findContainingList(node: Node): SyntaxList | undefined {
         // The node might be a list element (nonsynthetic) or a comma (synthetic). Either way, it will
         // be parented by the container of the SyntaxList, not the SyntaxList itself.
         // In order to find the list item index, we first need to locate SyntaxList itself and then search
         // for the position of the relevant node (or comma).
         const syntaxList = forEach(node.parent.getChildren(), c => {
             // find syntax list that covers the span of the node
-            if (c.kind === SyntaxKind.SyntaxList && c.pos <= node.pos && c.end >= node.end) {
+            if (isSyntaxList(c) && c.pos <= node.pos && c.end >= node.end) {
                 return c;
             }
         });
@@ -649,7 +656,8 @@ namespace ts {
 
                 const start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile, includeJsDocComment);
                 if (start > position) {
-                    continue;
+                    // If this child begins after position, then all subsequent children will as well.
+                    break;
                 }
 
                 const end = child.getEnd();
@@ -786,7 +794,7 @@ namespace ts {
 
     export function isInString(sourceFile: SourceFile, position: number): boolean {
         const previousToken = findPrecedingToken(position, sourceFile);
-        if (previousToken && previousToken.kind === SyntaxKind.StringLiteral) {
+        if (previousToken && isStringTextContainingNode(previousToken)) {
             const start = previousToken.getStart();
             const end = previousToken.getEnd();
 
@@ -1302,14 +1310,7 @@ namespace ts {
     export function getScriptKind(fileName: string, host?: LanguageServiceHost): ScriptKind {
         // First check to see if the script kind was specified by the host. Chances are the host
         // may override the default script kind for the file extension.
-        let scriptKind: ScriptKind;
-        if (host && host.getScriptKind) {
-            scriptKind = host.getScriptKind(fileName);
-        }
-        if (!scriptKind) {
-            scriptKind = getScriptKindFromFileName(fileName);
-        }
-        return ensureScriptKind(fileName, scriptKind);
+        return ensureScriptKind(fileName, host && host.getScriptKind && host.getScriptKind(fileName));
     }
 
     export function getFirstNonSpaceCharacterPosition(text: string, position: number) {

src/tsconfig-base.json

@@ -6,6 +6,7 @@
         "noImplicitThis": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
+        "alwaysStrict": true,
         "pretty": true,
         "preserveConstEnums": true,
         "stripInternal": true,

tests/baselines/reference/argumentsObjectCreatesRestForJs.types

@@ -35,13 +35,13 @@ someRest(1, 2, 3);
  * @param {number} x - a thing
  */
 function jsdocced(x) { arguments; }
->jsdocced : (x: number) => void
+>jsdocced : (x: number, ...args: any[]) => void
 >x : number
 >arguments : IArguments
 
 jsdocced(1);
 >jsdocced(1) : void
->jsdocced : (x: number) => void
+>jsdocced : (x: number, ...args: any[]) => void
 >1 : 1
 
 function dontDoubleRest(x, ...y) { arguments; }

tests/baselines/reference/asyncAliasReturnType_es6.symbols

@@ -2,7 +2,7 @@
 type PromiseAlias<T> = Promise<T>;
 >PromiseAlias : Symbol(PromiseAlias, Decl(asyncAliasReturnType_es6.ts, 0, 0))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
 
 async function f(): PromiseAlias<void> {

tests/baselines/reference/asyncArrowFunction1_es2017.symbols

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017.ts ===
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };

tests/baselines/reference/asyncArrowFunction1_es6.symbols

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts ===
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 0, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 };

tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.symbols

@@ -65,7 +65,7 @@ async function fn3() {
 
 async function fn4(): Promise<number> {
 >fn4 : Symbol(fn4, Decl(asyncAwaitWithCapturedBlockScopeVar.ts, 24, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     let ar = [];
 >ar : Symbol(ar, Decl(asyncAwaitWithCapturedBlockScopeVar.ts, 27, 7))

tests/baselines/reference/asyncAwait_es2017.symbols

@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es2017.ts, 0, 0), Decl(asyncAwait_es2017.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es2017.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es2017.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es2017.ts, 0, 0), Decl(asyncAwait_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es2017.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es2017.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es2017.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es2017.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es2017.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es2017.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es2017.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es2017.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es2017.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es2017.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es2017.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es2017.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwait_es2017.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwait_es2017.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es2017.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es2017.ts, 32, 37))

tests/baselines/reference/asyncAwait_es6.symbols

@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwait_es6.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))

tests/baselines/reference/asyncFunctionDeclaration11_es2017.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration11_es2017.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }

tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }

tests/baselines/reference/asyncFunctionDeclaration14_es2017.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration14_es2017.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
   return;
 }

tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
   return;
 }

tests/baselines/reference/asyncFunctionDeclaration1_es2017.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration1_es2017.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }

tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }

tests/baselines/reference/asyncFunctionReturnType.symbols

@@ -8,7 +8,7 @@ async function fAsync() {
 
 async function fAsyncExplicit(): Promise<[number, boolean]> {
 >fAsyncExplicit : Symbol(fAsyncExplicit, Decl(asyncFunctionReturnType.ts, 3, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     // This is contextually typed as a tuple.
     return [1, true];
@@ -29,7 +29,7 @@ async function fIndexedTypeForStringProp(obj: Obj): Promise<Obj["stringProp"]> {
 >fIndexedTypeForStringProp : Symbol(fIndexedTypeForStringProp, Decl(asyncFunctionReturnType.ts, 14, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 16, 41))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.stringProp;
@@ -42,12 +42,12 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 >fIndexedTypeForPromiseOfStringProp : Symbol(fIndexedTypeForPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 18, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
@@ -58,12 +58,12 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 >fIndexedTypeForExplicitPromiseOfStringProp : Symbol(fIndexedTypeForExplicitPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 22, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 24, 58))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -75,7 +75,7 @@ async function fIndexedTypeForAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
 >fIndexedTypeForAnyProp : Symbol(fIndexedTypeForAnyProp, Decl(asyncFunctionReturnType.ts, 26, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 28, 38))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.anyProp;
@@ -88,12 +88,12 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 >fIndexedTypeForPromiseOfAnyProp : Symbol(fIndexedTypeForPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 30, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
@@ -104,12 +104,12 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 >fIndexedTypeForExplicitPromiseOfAnyProp : Symbol(fIndexedTypeForExplicitPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 34, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 36, 55))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -123,7 +123,7 @@ async function fGenericIndexedTypeForStringProp<TObj extends Obj>(obj: TObj): Pr
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 40, 66))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
 
     return obj.stringProp;
@@ -138,12 +138,12 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
@@ -156,12 +156,12 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 48, 83))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -175,7 +175,7 @@ async function fGenericIndexedTypeForAnyProp<TObj extends Obj>(obj: TObj): Promi
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 52, 63))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
 
     return obj.anyProp;
@@ -190,12 +190,12 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
@@ -208,12 +208,12 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 60, 80))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -231,7 +231,7 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 64, 93))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
 
@@ -250,13 +250,13 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
 
     return Promise.resolve(obj[key]);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 68, 92))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
@@ -272,13 +272,13 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 72, 110))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 
     return Promise.resolve<TObj[K]>(obj[key]);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))

tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols

@@ -105,7 +105,7 @@ declare function resolve1<T>(value: T): Promise<T>;
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
 >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 29))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 17, 26))
 
 declare function resolve2<T>(value: T): Windows.Foundation.IPromise<T>;

tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols

@@ -2,7 +2,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 35))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 5))

tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols

@@ -2,7 +2,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 35))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 5))

tests/baselines/reference/asyncUseStrict_es2017.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es2017.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     "use strict";
     var b = await p || a;

tests/baselines/reference/asyncUseStrict_es6.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     "use strict";
     var b = await p || a;

tests/baselines/reference/awaitBinaryExpression1_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es2017.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression1_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression2_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es2017.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression2_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression3_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es2017.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es2017.ts, 1, 31))

tests/baselines/reference/awaitBinaryExpression3_es6.symbols

@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))

tests/baselines/reference/awaitBinaryExpression4_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es2017.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression4_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression5_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es2017.ts, 1, 32))

tests/baselines/reference/awaitBinaryExpression5_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))

tests/baselines/reference/awaitCallExpression1_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression1_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression2_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression2_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression3_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression3_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression4_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression4_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression5_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression5_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression6_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression6_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es6.ts, 5, 84))

tests/baselines/reference/awaitCallExpression7_es2017.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es2017.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es2017.ts, 5, 84))

tests/baselines/reference/awaitCallExpression7_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es6.ts, 5, 84))