Merge branch 'master' into undefinedzilla

Author: Andy Hanson

scripts/buildProtocol.ts

@@ -178,7 +178,7 @@ function writeProtocolFile(outputFile: string, protocolTs: string, typeScriptSer
     ts.sys.writeFile(outputFile, protocolDts);
 
     if (diagnostics.length) {
-        const flattenedDiagnostics = diagnostics.map(d => `${ts.flattenDiagnosticMessageText(d.messageText, "\n")} at ${d.file!.fileName} line ${d.start!}`).join("\n");
+        const flattenedDiagnostics = diagnostics.map(d => `${ts.flattenDiagnosticMessageText(d.messageText, "\n")} at ${d.file ? d.file.fileName : "<unknown>"} line ${d.start}`).join("\n");
         throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
     }
 }

src/compiler/checker.ts

@@ -325,6 +325,16 @@ namespace ts {
                     return diagnostics;
                 }
             },
+
+            runWithCancellationToken: (token, callback) => {
+                try {
+                    cancellationToken = token;
+                    return callback(checker);
+                }
+                finally {
+                    cancellationToken = undefined;
+                }
+            }
         };
 
         const tupleTypes: GenericType[] = [];
@@ -2130,14 +2140,22 @@ namespace ts {
             return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
         }
 
+        /**
+         * For prototype-property methods like `A.prototype.m = function () ...`, try to resolve names in the scope of `A` too.
+         * Note that prototype-property assignment to locations outside the current file (eg globals) doesn't work, so
+         * name resolution won't work either.
+         */
         function resolveEntityNameFromJSPrototype(name: Identifier, meaning: SymbolFlags) {
             if (isJSDocTypeReference(name.parent) && isJSDocTag(name.parent.parent.parent)) {
                 const host = getJSDocHost(name.parent.parent.parent as JSDocTag);
                 if (isExpressionStatement(host) &&
                     isBinaryExpression(host.expression) &&
                     getSpecialPropertyAssignmentKind(host.expression) === SpecialPropertyAssignmentKind.PrototypeProperty) {
-                    const secondaryLocation = getSymbolOfNode(host.expression.left)!.parent!.valueDeclaration;
-                    return resolveName(secondaryLocation, name.escapedText, meaning, /*nameNotFoundMessage*/ undefined, name, /*isUse*/ true);
+                    const symbol = getSymbolOfNode(host.expression.left);
+                    if (symbol) {
+                        const secondaryLocation = symbol.parent!.valueDeclaration;
+                        return resolveName(secondaryLocation, name.escapedText, meaning, /*nameNotFoundMessage*/ undefined, name, /*isUse*/ true);
+                    }
                 }
             }
         }
@@ -3000,6 +3018,9 @@ namespace ts {
             }
 
             function typeToTypeNodeHelper(type: Type, context: NodeBuilderContext): TypeNode | undefined {
+                if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
+                    cancellationToken.throwIfCancellationRequested();
+                }
                 const inTypeAlias = context.flags & NodeBuilderFlags.InTypeAlias;
                 context.flags &= ~NodeBuilderFlags.InTypeAlias;
 

src/compiler/emitter.ts

@@ -1441,9 +1441,9 @@ namespace ts {
 
         function emitElementAccessExpression(node: ElementAccessExpression) {
             emitExpression(node.expression);
-            const openPos = emitTokenWithComment(SyntaxKind.OpenBracketToken, node.expression.end, writePunctuation, node);
+            emitTokenWithComment(SyntaxKind.OpenBracketToken, node.expression.end, writePunctuation, node);
             emitExpression(node.argumentExpression);
-            emitTokenWithComment(SyntaxKind.CloseBracketToken, node.argumentExpression ? node.argumentExpression.end : openPos, writePunctuation, node);
+            emitTokenWithComment(SyntaxKind.CloseBracketToken, node.argumentExpression.end, writePunctuation, node);
         }
 
         function emitCallExpression(node: CallExpression) {

src/compiler/types.ts

@@ -3003,6 +3003,13 @@ namespace ts {
          * Others are added in computeSuggestionDiagnostics.
          */
         /* @internal */ getSuggestionDiagnostics(file: SourceFile): ReadonlyArray<Diagnostic>;
+
+        /**
+         * Depending on the operation performed, it may be appropriate to throw away the checker
+         * if the cancellation token is triggered. Typically, if it is used for error checking
+         * and the operation is cancelled, then it should be discarded, otherwise it is safe to keep.
+         */
+        runWithCancellationToken<T>(token: CancellationToken, cb: (checker: TypeChecker) => T): T;
     }
 
     /* @internal */

src/harness/harness.ts

@@ -304,14 +304,13 @@ namespace Utils {
                 o.containsParseError = true;
             }
 
-            ts.forEach(Object.getOwnPropertyNames(n), propertyName => {
+            for (const propertyName of Object.getOwnPropertyNames(n) as ReadonlyArray<keyof ts.SourceFile | keyof ts.Identifier>) {
                 switch (propertyName) {
                     case "parent":
                     case "symbol":
                     case "locals":
                     case "localSymbol":
                     case "kind":
-                    case "semanticDiagnostics":
                     case "id":
                     case "nodeCount":
                     case "symbolCount":
@@ -334,7 +333,6 @@ namespace Utils {
                         }
                         break;
 
-                    case "referenceDiagnostics":
                     case "parseDiagnostics":
                         o[propertyName] = convertDiagnostics((<any>n)[propertyName]);
                         break;
@@ -355,9 +353,7 @@ namespace Utils {
                     default:
                         o[propertyName] = (<any>n)[propertyName];
                 }
-
-                return undefined;
-            });
+            }
 
             return o;
         }

src/harness/unittests/cancellableLanguageServiceOperations.ts

@@ -0,0 +1,95 @@
+/// <reference path="..\harness.ts" />
+
+namespace ts {
+    describe("cancellableLanguageServiceOperations", () => {
+        const file = `
+        function foo(): void;
+        function foo<T>(x: T): T;
+        function foo<T>(x?: T): T | void {}
+        foo(f);
+        `;
+        it("can cancel signature help mid-request", () => {
+            verifyOperationCancelledAfter(file, 4, service => // Two calls are top-level in services, one is the root type, and the second should be for the parameter type
+                service.getSignatureHelpItems("file.ts", file.lastIndexOf("f"))!,
+                r => assert.exists(r.items[0])
+            );
+        });
+
+        it("can cancel find all references mid-request", () => {
+            verifyOperationCancelledAfter(file, 3, service => // Two calls are top-level in services, one is the root type
+                service.findReferences("file.ts", file.lastIndexOf("o"))!,
+                r => assert.exists(r[0].definition)
+            );
+        });
+
+        it("can cancel quick info mid-request", () => {
+            verifyOperationCancelledAfter(file, 1, service => // The LS doesn't do any top-level checks on the token for quickinfo, so the first check is within the checker
+                service.getQuickInfoAtPosition("file.ts", file.lastIndexOf("o"))!,
+                r => assert.exists(r.displayParts)
+            );
+        });
+
+        it("can cancel completion entry details mid-request", () => {
+            const options: FormatCodeSettings = {
+                indentSize: 4,
+                tabSize: 4,
+                newLineCharacter: "\n",
+                convertTabsToSpaces: true,
+                indentStyle: IndentStyle.Smart,
+                insertSpaceAfterConstructor: false,
+                insertSpaceAfterCommaDelimiter: true,
+                insertSpaceAfterSemicolonInForStatements: true,
+                insertSpaceBeforeAndAfterBinaryOperators: true,
+                insertSpaceAfterKeywordsInControlFlowStatements: true,
+                insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
+                insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+                insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+                insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+                insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+                insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+                insertSpaceBeforeFunctionParenthesis: false,
+                placeOpenBraceOnNewLineForFunctions: false,
+                placeOpenBraceOnNewLineForControlBlocks: false,
+            };
+            verifyOperationCancelledAfter(file, 1, service => // The LS doesn't do any top-level checks on the token for completion entry details, so the first check is within the checker
+                service.getCompletionEntryDetails("file.ts", file.lastIndexOf("f"), "foo", options, /*content*/ undefined, {})!,
+                r => assert.exists(r.displayParts)
+            );
+        });
+    });
+
+    function verifyOperationCancelledAfter<T>(content: string, cancelAfter: number, operation: (service: LanguageService) => T, validator: (arg: T) => void) {
+        let checks = 0;
+        const token: HostCancellationToken = {
+            isCancellationRequested() {
+                checks++;
+                const result = checks >= cancelAfter;
+                if (result) {
+                    checks = -Infinity; // Cancel just once, then disable cancellation, effectively
+                }
+                return result;
+            }
+        };
+        const adapter = new Harness.LanguageService.NativeLanguageServiceAdapter(token);
+        const host = adapter.getHost();
+        host.addScript("file.ts", content, /*isRootFile*/ true);
+        const service = adapter.getLanguageService();
+        assertCancelled(() => operation(service));
+        validator(operation(service));
+    }
+
+    /**
+     * We don't just use `assert.throws` because it doesn't validate instances for thrown objects which do not inherit from `Error`
+     */
+    function assertCancelled(cb: () => void) {
+        let caught: any;
+        try {
+            cb();
+        }
+        catch (e) {
+            caught = e;
+        }
+        assert.exists(caught, "Expected operation to be cancelled, but was not");
+        assert.instanceOf(caught, OperationCanceledException);
+    }
+}

src/services/completions.ts

@@ -534,6 +534,7 @@ namespace ts.Completions {
         formatContext: formatting.FormatContext,
         getCanonicalFileName: GetCanonicalFileName,
         preferences: UserPreferences,
+        cancellationToken: CancellationToken,
     ): CompletionEntryDetails | undefined {
         const typeChecker = program.getTypeChecker();
         const compilerOptions = program.getCompilerOptions();
@@ -544,7 +545,7 @@ namespace ts.Completions {
             const stringLiteralCompletions = !contextToken || !isStringLiteralLike(contextToken)
                 ? undefined
                 : getStringLiteralCompletionEntries(sourceFile, contextToken, position, typeChecker, compilerOptions, host);
-            return stringLiteralCompletions && stringLiteralCompletionDetails(name, contextToken!, stringLiteralCompletions, sourceFile, typeChecker); // TODO: GH#18217
+            return stringLiteralCompletions && stringLiteralCompletionDetails(name, contextToken!, stringLiteralCompletions, sourceFile, typeChecker, cancellationToken); // TODO: GH#18217
         }
 
         // Compute all the completion symbols again.
@@ -566,28 +567,31 @@ namespace ts.Completions {
             case "symbol": {
                 const { symbol, location, symbolToOriginInfoMap, previousToken } = symbolCompletion;
                 const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(symbolToOriginInfoMap, symbol, program, typeChecker, host, compilerOptions, sourceFile, previousToken, formatContext, getCanonicalFileName, program.getSourceFiles(), preferences);
-                return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location!, codeActions, sourceDisplay); // TODO: GH#18217
+                return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location!, cancellationToken, codeActions, sourceDisplay); // TODO: GH#18217
             }
             case "none":
                 // Didn't find a symbol with this name.  See if we can find a keyword instead.
                 return allKeywordsCompletions().some(c => c.name === name) ? createCompletionDetails(name, ScriptElementKindModifier.none, ScriptElementKind.keyword, [displayPart(name, SymbolDisplayPartKind.keyword)]) : undefined;
         }
     }
 
-    function createCompletionDetailsForSymbol(symbol: Symbol, checker: TypeChecker, sourceFile: SourceFile, location: Node, codeActions?: CodeAction[], sourceDisplay?: SymbolDisplayPart[]): CompletionEntryDetails {
-        const { displayParts, documentation, symbolKind, tags } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, sourceFile, location, location, SemanticMeaning.All);
+    function createCompletionDetailsForSymbol(symbol: Symbol, checker: TypeChecker, sourceFile: SourceFile, location: Node, cancellationToken: CancellationToken, codeActions?: CodeAction[], sourceDisplay?: SymbolDisplayPart[]): CompletionEntryDetails {
+        const { displayParts, documentation, symbolKind, tags } =
+            checker.runWithCancellationToken(cancellationToken, checker =>
+                SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, sourceFile, location, location, SemanticMeaning.All)
+            );
         return createCompletionDetails(symbol.name, SymbolDisplay.getSymbolModifiers(symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay);
     }
 
-    function stringLiteralCompletionDetails(name: string, location: Node, completion: StringLiteralCompletion, sourceFile: SourceFile, checker: TypeChecker): CompletionEntryDetails | undefined {
+    function stringLiteralCompletionDetails(name: string, location: Node, completion: StringLiteralCompletion, sourceFile: SourceFile, checker: TypeChecker, cancellationToken: CancellationToken): CompletionEntryDetails | undefined {
         switch (completion.kind) {
             case StringLiteralCompletionKind.Paths: {
                 const match = find(completion.paths, p => p.name === name);
                 return match && createCompletionDetails(name, ScriptElementKindModifier.none, match.kind, [textPart(name)]);
             }
             case StringLiteralCompletionKind.Properties: {
                 const match = find(completion.symbols, s => s.name === name);
-                return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location);
+                return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken);
             }
             case StringLiteralCompletionKind.Types:
                 return find(completion.types, t => t.value === name) ? createCompletionDetails(name, ScriptElementKindModifier.none, ScriptElementKind.typeElement, [textPart(name)]) : undefined;

src/services/findAllReferences.ts

@@ -45,7 +45,10 @@ namespace ts.FindAllReferences {
         const checker = program.getTypeChecker();
         return !referencedSymbols || !referencedSymbols.length ? undefined : mapDefined<SymbolAndEntries, ReferencedSymbol>(referencedSymbols, ({ definition, references }) =>
             // Only include referenced symbols that have a valid definition.
-            definition && { definition: definitionToReferencedSymbolDefinitionInfo(definition, checker, node), references: references.map(toReferenceEntry) });
+            definition && {
+                definition: checker.runWithCancellationToken(cancellationToken, checker => definitionToReferencedSymbolDefinitionInfo(definition, checker, node)),
+                references: references.map(toReferenceEntry)
+            });
     }
 
     export function getImplementationsAtPosition(program: Program, cancellationToken: CancellationToken, sourceFiles: ReadonlyArray<SourceFile>, sourceFile: SourceFile, position: number): ImplementationLocation[] | undefined {

src/services/services.ts

@@ -553,7 +553,6 @@ namespace ts {
         public typeReferenceDirectives: FileReference[];
 
         public syntacticDiagnostics: Diagnostic[];
-        public referenceDiagnostics: Diagnostic[];
         public parseDiagnostics: Diagnostic[];
         public bindDiagnostics: Diagnostic[];
 
@@ -1432,7 +1431,9 @@ namespace ts {
                 host,
                 (formattingOptions && formatting.getFormatContext(formattingOptions))!, // TODO: GH#18217
                 getCanonicalFileName,
-                preferences);
+                preferences,
+                cancellationToken,
+            );
         }
 
         function getCompletionEntrySymbol(fileName: string, position: number, name: string, source?: string): Symbol | undefined {
@@ -1473,7 +1474,7 @@ namespace ts {
                             kind: ScriptElementKind.unknown,
                             kindModifiers: ScriptElementKindModifier.none,
                             textSpan: createTextSpanFromNode(node, sourceFile),
-                            displayParts: typeToDisplayParts(typeChecker, type, getContainerNode(node)),
+                            displayParts: typeChecker.runWithCancellationToken(cancellationToken, typeChecker => typeToDisplayParts(typeChecker, type, getContainerNode(node))),
                             documentation: type.symbol ? type.symbol.getDocumentationComment(typeChecker) : undefined,
                             tags: type.symbol ? type.symbol.getJsDocTags() : undefined
                         };
@@ -1482,7 +1483,9 @@ namespace ts {
                 return undefined;
             }
 
-            const { symbolKind, displayParts, documentation, tags } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, getContainerNode(node), node);
+            const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(cancellationToken, typeChecker =>
+                SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, getContainerNode(node), node)
+            );
             return {
                 kind: symbolKind,
                 kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),