Support completions for local named exports (microsoft#37606)

* Support completions for local named exports

* Add JSDoc

* Use sort text instead of filtering

* Revert new CompletionKind

* Return valid completions even when export declaration is in an invalid place

Author: andrewbranch

src/services/completions.ts

@@ -1271,6 +1271,7 @@ namespace ts.Completions {
         function tryGetGlobalSymbols(): boolean {
             const result: GlobalsSearch = tryGetObjectLikeCompletionSymbols()
                 || tryGetImportOrExportClauseCompletionSymbols()
+                || tryGetLocalNamedExportCompletionSymbols()
                 || tryGetConstructorCompletion()
                 || tryGetClassLikeCompletionSymbols()
                 || tryGetJsxCompletionSymbols()
@@ -1881,19 +1882,17 @@ namespace ts.Completions {
          *      export { | };
          *
          * Relevant symbols are stored in the captured 'symbols' variable.
-         *
-         * @returns true if 'symbols' was successfully populated; false otherwise.
          */
         function tryGetImportOrExportClauseCompletionSymbols(): GlobalsSearch {
             // `import { |` or `import { a as 0, | }`
             const namedImportsOrExports = contextToken && (contextToken.kind === SyntaxKind.OpenBraceToken || contextToken.kind === SyntaxKind.CommaToken)
                 ? tryCast(contextToken.parent, isNamedImportsOrExports) : undefined;
             if (!namedImportsOrExports) return GlobalsSearch.Continue;
 
-            // cursor is in an import clause
-            // try to show exported member for imported module
+            // try to show exported member for imported/re-exported module
             const { moduleSpecifier } = namedImportsOrExports.kind === SyntaxKind.NamedImports ? namedImportsOrExports.parent.parent : namedImportsOrExports.parent;
-            const moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier!); // TODO: GH#18217
+            if (!moduleSpecifier) return namedImportsOrExports.kind === SyntaxKind.NamedImports ? GlobalsSearch.Fail : GlobalsSearch.Continue;
+            const moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier); // TODO: GH#18217
             if (!moduleSpecifierSymbol) return GlobalsSearch.Fail;
 
             completionKind = CompletionKind.MemberLike;
@@ -1904,6 +1903,36 @@ namespace ts.Completions {
             return GlobalsSearch.Success;
         }
 
+        /**
+         * Adds local declarations for completions in named exports:
+         *
+         *   export { | };
+         *
+         * Does not check for the absence of a module specifier (`export {} from "./other"`)
+         * because `tryGetImportOrExportClauseCompletionSymbols` runs first and handles that,
+         * preventing this function from running.
+         */
+        function tryGetLocalNamedExportCompletionSymbols(): GlobalsSearch {
+            const namedExports = contextToken && (contextToken.kind === SyntaxKind.OpenBraceToken || contextToken.kind === SyntaxKind.CommaToken)
+                ? tryCast(contextToken.parent, isNamedExports)
+                : undefined;
+
+            if (!namedExports) {
+                return GlobalsSearch.Continue;
+            }
+
+            const localsContainer = findAncestor(namedExports, or(isSourceFile, isModuleDeclaration))!;
+            completionKind = CompletionKind.None;
+            isNewIdentifierLocation = false;
+            localsContainer.locals?.forEach((symbol, name) => {
+                symbols.push(symbol);
+                if (localsContainer.symbol?.exports?.has(name)) {
+                    symbolToSortTextMap[getSymbolId(symbol)] = SortText.OptionalMember;
+                }
+            });
+            return GlobalsSearch.Success;
+        }
+
         /**
          * Aggregates relevant symbols for completion in class declaration
          * Relevant symbols are stored in the captured 'symbols' variable.
@@ -2299,7 +2328,7 @@ namespace ts.Completions {
             }
         }
 
-        // Set SortText to OptionalMember if it is an optinoal member
+        // Set SortText to OptionalMember if it is an optional member
         function setSortTextToOptionalMember() {
             symbols.forEach(m => {
                 if (m.flags & SymbolFlags.Optional) {

tests/cases/fourslash/completionsInExport.ts

@@ -0,0 +1,38 @@
+/// <reference path="fourslash.ts" />
+
+////const a = "a";
+////type T = number;
+////export { /**/ };
+
+verify.completions({
+  marker: "",
+  exact: ["a", "T"]
+});
+
+// Deprioritize 'a' since it has been exported already.
+// (Keep it in the list because you can still do 'a as b'.)
+edit.insert("a, ");
+verify.completions({
+  exact: [{ name: "a", sortText: completion.SortText.OptionalMember }, "T"]
+});
+
+// No completions for new name
+edit.insert("T as ");
+verify.completions({
+  exact: []
+});
+
+// 'T' still hasn't been exported by name
+edit.insert("U, ");
+verify.completions({
+  exact: [{ name: "a", sortText: completion.SortText.OptionalMember }, "T"]
+});
+
+// 'a' and 'T' are back to the same priority
+edit.insert("T, ");
+verify.completions({
+  exact: [
+    { name: "a", sortText: completion.SortText.OptionalMember },
+    { name: "T", sortText: completion.SortText.OptionalMember }
+  ]
+});

tests/cases/fourslash/completionsInExport_invalid.ts

@@ -0,0 +1,12 @@
+/// <reference path="fourslash.ts" />
+
+////function topLevel() {}
+////if (!!true) {
+////  const blockScoped = 0;
+////  export { /**/ };
+////}
+
+verify.completions({
+  marker: "",
+  exact: ["topLevel"]
+});

tests/cases/fourslash/completionsInExport_moduleBlock.ts

@@ -0,0 +1,42 @@
+/// <reference path="fourslash.ts" />
+
+////const outOfScope = 0;
+////
+////declare module 'mod' {
+////  const a: string;
+////  type T = number;
+////  export { /**/ };
+////}
+
+verify.completions({
+  marker: "",
+  exact: ["a", "T"]
+});
+
+// Deprioritize 'a' since it has been exported already.
+// (Keep it in the list because you can still do 'a as b'.)
+edit.insert("a, ");
+verify.completions({
+  exact: [{ name: "a", sortText: completion.SortText.OptionalMember }, "T"]
+});
+
+// No completions for new name
+edit.insert("T as ");
+verify.completions({
+  exact: []
+});
+
+// 'T' still hasn't been exported by name
+edit.insert("U, ");
+verify.completions({
+  exact: [{ name: "a", sortText: completion.SortText.OptionalMember }, "T"]
+});
+
+// 'a' and 'T' are back to the same priority
+edit.insert("T, ");
+verify.completions({
+  exact: [
+    { name: "a", sortText: completion.SortText.OptionalMember },
+    { name: "T", sortText: completion.SortText.OptionalMember }
+  ]
+});