Add KeywordCompletionFilters.TypeKeywords

Andy Hanson · Andy Hanson · commit 7f745f37ac93 · 2018-01-23T08:51:58.000-08:00
diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -20,7 +20,8 @@ namespace ts.Completions {
         None,
         ClassElementKeywords,           // Keywords at class keyword
         ConstructorParameterKeywords,   // Keywords at constructor parameter
-        FunctionLikeBodyKeywords        // Keywords at function like body
+        FunctionLikeBodyKeywords,       // Keywords at function like body
+        TypeKeywords,
     }
 
     export function getCompletionsAtPosition(
@@ -565,7 +566,7 @@ namespace ts.Completions {
             }
             case "none": {
                 // Didn't find a symbol with this name.  See if we can find a keyword instead.
-                if (some(getKeywordCompletions(KeywordCompletionFilters.None), c => c.name === name)) {
+                if (allKeywordsCompletions().some(c => c.name === name)) {
                     return {
                         name,
                         kind: ScriptElementKind.keyword,
@@ -1163,26 +1164,24 @@ namespace ts.Completions {
         }
 
         function filterGlobalCompletion(symbols: Symbol[]): void {
+            const isTypeCompletion = insideJsDocTagTypeExpression || !isContextTokenValueLocation(contextToken) && (isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken));
+            if (isTypeCompletion) keywordFilters = KeywordCompletionFilters.TypeKeywords;
+
             filterMutate(symbols, symbol => {
                 if (!isSourceFile(location)) {
                     // export = /**/ here we want to get all meanings, so any symbol is ok
                     if (isExportAssignment(location.parent)) {
                         return true;
                     }
 
-                    // This is an alias, follow what it aliases
-                    if (symbol && symbol.flags & SymbolFlags.Alias) {
-                        symbol = typeChecker.getAliasedSymbol(symbol);
-                    }
+                    symbol = skipAlias(symbol, typeChecker);
 
                     // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace)
                     if (isInRightSideOfInternalImportEqualsDeclaration(location)) {
                         return !!(symbol.flags & SymbolFlags.Namespace);
                     }
 
-                    if (insideJsDocTagTypeExpression ||
-                        (!isContextTokenValueLocation(contextToken) &&
-                            (isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken)))) {
+                    if (isTypeCompletion) {
                         // Its a type, but you can reach it by namespace.type as well
                         return symbolCanBeReferencedAtTypeLocation(symbol);
                     }
@@ -1199,7 +1198,7 @@ namespace ts.Completions {
                 contextToken.parent.kind === SyntaxKind.TypeQuery;
         }
 
-        function isContextTokenTypeLocation(contextToken: Node) {
+        function isContextTokenTypeLocation(contextToken: Node): boolean {
             if (contextToken) {
                 const parentKind = contextToken.parent.kind;
                 switch (contextToken.kind) {
@@ -1217,6 +1216,7 @@ namespace ts.Completions {
                         return parentKind === SyntaxKind.AsExpression;
                 }
             }
+            return false;
         }
 
         function symbolCanBeReferencedAtTypeLocation(symbol: Symbol): boolean {
@@ -2130,50 +2130,40 @@ namespace ts.Completions {
     }
 
     // A cache of completion entries for keywords, these do not change between sessions
-    const _keywordCompletions: CompletionEntry[][] = [];
-    function getKeywordCompletions(keywordFilter: KeywordCompletionFilters): CompletionEntry[] {
-        const completions = _keywordCompletions[keywordFilter];
-        if (completions) {
-            return completions;
-        }
-        return _keywordCompletions[keywordFilter] = generateKeywordCompletions(keywordFilter);
-
-        type FilterKeywordCompletions = (entryName: string) => boolean;
-        function generateKeywordCompletions(keywordFilter: KeywordCompletionFilters): CompletionEntry[] {
-            switch (keywordFilter) {
-                case KeywordCompletionFilters.None:
-                    return getAllKeywordCompletions();
-                case KeywordCompletionFilters.ClassElementKeywords:
-                    return getFilteredKeywordCompletions(isClassMemberCompletionKeywordText);
-                case KeywordCompletionFilters.ConstructorParameterKeywords:
-                    return getFilteredKeywordCompletions(isConstructorParameterCompletionKeywordText);
-                case KeywordCompletionFilters.FunctionLikeBodyKeywords:
-                    return getFilteredKeywordCompletions(isFunctionLikeBodyCompletionKeywordText);
-                default:
-                    Debug.assertNever(keywordFilter);
-            }
-        }
-
-        function getAllKeywordCompletions() {
-            const allKeywordsCompletions: CompletionEntry[] = [];
-            for (let i = SyntaxKind.FirstKeyword; i <= SyntaxKind.LastKeyword; i++) {
+    const _keywordCompletions: ReadonlyArray<CompletionEntry>[] = [];
+    const allKeywordsCompletions: () => ReadonlyArray<CompletionEntry> = ts.memoize(() => {
+        const res: CompletionEntry[] = [];
+        for (let i = SyntaxKind.FirstKeyword; i <= SyntaxKind.LastKeyword; i++) {
+            res.push(createKeywordCompletionEntry(i));
+        }
+        return res;
+    });
+    function createKeywordCompletionEntry(kind: SyntaxKind): CompletionEntry {
+        return {
+            name: tokenToString(kind),
+            kind: ScriptElementKind.keyword,
+            kindModifiers: ScriptElementKindModifier.none,
+            sortText: "0"
+        };
+    }
+    function getKeywordCompletions(keywordFilter: KeywordCompletionFilters): ReadonlyArray<CompletionEntry> {
+        return _keywordCompletions[keywordFilter] || (_keywordCompletions[keywordFilter] = allKeywordsCompletions().filter(entry => isValidKeyword(keywordFilter, stringToToken(entry.name))));
+    }
+    function isValidKeyword(keywordFilter: KeywordCompletionFilters, kind: SyntaxKind): boolean {
+        switch (keywordFilter) {
+            case KeywordCompletionFilters.None:
                 // "undefined" is a global variable, so don't need a keyword completion for it.
-                if (i === SyntaxKind.UndefinedKeyword) continue;
-                allKeywordsCompletions.push({
-                    name: tokenToString(i),
-                    kind: ScriptElementKind.keyword,
-                    kindModifiers: ScriptElementKindModifier.none,
-                    sortText: "0"
-                });
-            }
-            return allKeywordsCompletions;
-        }
-
-        function getFilteredKeywordCompletions(filterFn: FilterKeywordCompletions) {
-            return filter(
-                getKeywordCompletions(KeywordCompletionFilters.None),
-                entry => filterFn(entry.name)
-            );
+                return kind !== SyntaxKind.UndefinedKeyword;
+            case KeywordCompletionFilters.ClassElementKeywords:
+                return isClassMemberCompletionKeyword(kind);
+            case KeywordCompletionFilters.ConstructorParameterKeywords:
+                return isConstructorParameterCompletionKeyword(kind);
+            case KeywordCompletionFilters.FunctionLikeBodyKeywords:
+                return isFunctionLikeBodyCompletionKeyword(kind);
+            case KeywordCompletionFilters.TypeKeywords:
+                return kind === SyntaxKind.KeyOfKeyword || kind === SyntaxKind.UniqueKeyword || ts.isTypeKeyword(kind);
+            default:
+                Debug.assertNever(keywordFilter);
         }
     }
 
@@ -2227,10 +2217,6 @@ namespace ts.Completions {
         return true;
     }
 
-    function isFunctionLikeBodyCompletionKeywordText(text: string) {
-        return isFunctionLikeBodyCompletionKeyword(stringToToken(text));
-    }
-
     function isEqualityOperatorKind(kind: ts.SyntaxKind): kind is EqualityOperator {
         switch (kind) {
             case ts.SyntaxKind.EqualsEqualsEqualsToken:
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -1076,6 +1076,8 @@ namespace ts {
         SyntaxKind.StringKeyword,
         SyntaxKind.SymbolKeyword,
         SyntaxKind.VoidKeyword,
+        SyntaxKind.NullKeyword,
+        SyntaxKind.UndefinedKeyword,
     ];
 
     export function isTypeKeyword(kind: SyntaxKind): boolean {
diff --git a/tests/cases/fourslash/completionsTypeKeywords.ts b/tests/cases/fourslash/completionsTypeKeywords.ts
@@ -0,0 +1,7 @@
+/// <reference path="fourslash.ts" />
+
+////type T = /**/
+
+goTo.marker();
+verify.completionListContains("undefined", "undefined", undefined, "keyword");
+verify.not.completionListContains("await");
