Add exported members of all project files in the global completion list

src/compiler/checker.ts

@@ -6233,11 +6233,13 @@ namespace ts {
 
         function symbolsToArray(symbols: SymbolTable): Symbol[] {
             const result: Symbol[] = [];
-            symbols.forEach((symbol, id) => {
-                if (!isReservedMemberName(id)) {
-                    result.push(symbol);
-                }
-            });
+            if (symbols) {
+                symbols.forEach((symbol, id) => {
+                    if (!isReservedMemberName(id)) {
+                        result.push(symbol);
+                    }
+                });
+            }
             return result;
         }
 

src/harness/unittests/tsserverProjectSystem.ts

@@ -3751,6 +3751,43 @@ namespace ts.projectSystem {
         });
     });
 
+    describe("import in completion list", () => {
+        it("should include exported members of all source files", () => {
+            const file1: FileOrFolder = {
+                path: "/a/b/file1.ts",
+                content: `
+                export function Test1() { }
+                export function Test2() { }
+                `
+            };
+            const file2: FileOrFolder = {
+                path: "/a/b/file2.ts",
+                content: `
+                import { Test2 } from "./file1";
+
+                t`
+            };
+            const configFile: FileOrFolder = {
+                path: "/a/b/tsconfig.json",
+                content: "{}"
+            };
+
+            const host = createServerHost([file1, file2, configFile]);
+            const service = createProjectService(host);
+            service.openClientFile(file2.path);
+
+            const completions1 = service.configuredProjects[0].getLanguageService().getCompletionsAtPosition(file2.path, file2.content.length);
+            const test1Entry = find(completions1.entries, e => e.name === "Test1");
+            const test2Entry = find(completions1.entries, e => e.name === "Test2");
+
+            assert.isDefined(test1Entry, "should contain 'Test1'");
+            assert.isDefined(test2Entry, "should contain 'Test2'");
+
+            assert.isTrue(test1Entry.hasAction, "should set the 'hasAction' property to true for Test1");
+            assert.isUndefined(test2Entry.hasAction, "should not set the 'hasAction' property for Test2");
+        });
+    });
+
     describe("import helpers", () => {
         it("should not crash in tsserver", () => {
             const f1 = {
@@ -4090,6 +4127,70 @@ namespace ts.projectSystem {
         });
     });
 
+    describe("completion entry with code actions", () => {
+        it("should work for symbols from non-imported modules", () => {
+            const moduleFile = {
+                path: "/a/b/moduleFile.ts",
+                content: `export const guitar = 10;`
+            };
+            const file1 = {
+                path: "/a/b/file2.ts",
+                content: `var x:`
+            };
+            const globalFile = {
+                path: "/a/b/globalFile.ts",
+                content: `interface Jazz { }`
+            };
+            const ambientModuleFile = {
+                path: "/a/b/ambientModuleFile.ts",
+                content:
+                `declare module "windyAndWarm" {
+                    export const chetAtkins = "great";
+                }`
+            };
+            const defaultModuleFile = {
+                path: "/a/b/defaultModuleFile.ts",
+                content:
+                `export default function egyptianElla() { };`
+            };
+            const configFile = {
+                path: "/a/b/tsconfig.json",
+                content: "{}"
+            };
+
+            const host = createServerHost([moduleFile, file1, globalFile, ambientModuleFile, defaultModuleFile, configFile]);
+            const session = createSession(host);
+            const projectService = session.getProjectService();
+            projectService.openClientFile(file1.path);
+
+            checkEntryDetail(1, "guitar", /*hasAction*/ true, `import { guitar } from "./moduleFile";\n\n`);
+            checkEntryDetail(1, "chetAtkins", /*hasAction*/ true, `import { chetAtkins } from "windyAndWarm";\n\n`);
+            checkEntryDetail(1, "egyptianElla", /*hasAction*/ true, `import egyptianElla from "./defaultModuleFile";\n\n`);
+            checkEntryDetail(7, "Jazz", /*hasAction*/ false);
+
+            function checkEntryDetail(offset: number, entryName: string, hasAction: boolean, insertString?: string) {
+                const request = makeSessionRequest<protocol.CompletionDetailsRequestArgs>(
+                    CommandNames.CompletionDetails,
+                    { entryNames: [entryName], file: file1.path, line: 1, offset, projectFileName: configFile.path });
+                const response = session.executeCommand(request).response as protocol.CompletionEntryDetails[];
+                assert.equal(response.length, 1);
+
+                const entryDetails = response[0];
+                if (!hasAction) {
+                    assert.isUndefined(entryDetails.codeActions);
+                }
+                else {
+                    const action = entryDetails.codeActions[0];
+                    assert.equal(action.changes[0].fileName, file1.path);
+                    assert.deepEqual(action.changes[0], <protocol.FileCodeEdits>{
+                        fileName: file1.path,
+                        textChanges: [{ start: { line: 1, offset: 1 }, end: { line: 1, offset: 1 }, newText: insertString }]
+                    });
+                }
+            }
+        });
+    });
+
     describe("maxNodeModuleJsDepth for inferred projects", () => {
         it("should be set to 2 if the project has js root files", () => {
             const file1: FileOrFolder = {

src/server/client.ts

@@ -198,7 +198,9 @@ namespace ts.server {
             const request = this.processRequest<protocol.CompletionDetailsRequest>(CommandNames.CompletionDetails, args);
             const response = this.processResponse<protocol.CompletionDetailsResponse>(request);
             Debug.assert(response.body.length === 1, "Unexpected length of completion details response body.");
-            return response.body[0];
+
+            const convertedCodeActions = map(response.body[0].codeActions, codeAction => this.convertCodeActions(codeAction, fileName));
+            return { ...response.body[0], codeActions: convertedCodeActions };
         }
 
         getCompletionEntrySymbol(_fileName: string, _position: number, _entryName: string): Symbol {

src/server/protocol.ts

@@ -1642,6 +1642,11 @@ namespace ts.server.protocol {
          * this span should be used instead of the default one.
          */
         replacementSpan?: TextSpan;
+        /**
+         * Indicating if commiting this completion entry will require additional code action to be
+         * made to avoid errors. The code action is normally adding an additional import statement.
+         */
+        hasAction?: true;
     }
 
     /**
@@ -1674,6 +1679,11 @@ namespace ts.server.protocol {
          * JSDoc tags for the symbol.
          */
         tags: JSDocTagInfo[];
+
+        /**
+         * The associated code actions for this entry
+         */
+        codeActions?: CodeAction[];
     }
 
     export interface CompletionsResponse extends Response {

src/server/session.ts

@@ -1178,9 +1178,15 @@ namespace ts.server {
             if (simplifiedResult) {
                 return mapDefined(completions && completions.entries, entry => {
                     if (completions.isMemberCompletion || (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) === 0)) {
-                        const { name, kind, kindModifiers, sortText, replacementSpan } = entry;
+                        const { name, kind, kindModifiers, sortText, replacementSpan, hasAction } = entry;
                         const convertedSpan = replacementSpan ? this.decorateSpan(replacementSpan, scriptInfo) : undefined;
-                        return { name, kind, kindModifiers, sortText, replacementSpan: convertedSpan };
+
+                        const newEntry: protocol.CompletionEntry = { name, kind, kindModifiers, sortText, replacementSpan: convertedSpan };
+                        // avoid serialization when hasAction = false
+                        if (hasAction) {
+                            newEntry.hasAction = true;
+                        }
+                        return newEntry;
                     }
                 }).sort((a, b) => compareStrings(a.name, b.name));
             }
@@ -1193,9 +1199,18 @@ namespace ts.server {
             const { file, project } = this.getFileAndProject(args);
             const scriptInfo = project.getScriptInfoForNormalizedPath(file);
             const position = this.getPosition(args, scriptInfo);
+            const formattingOptions = project.projectService.getFormatCodeOptions(file);
 
-            return mapDefined(args.entryNames, entryName =>
-                project.getLanguageService().getCompletionEntryDetails(file, position, entryName));
+            return mapDefined(args.entryNames, entryName => {
+                const details = project.getLanguageService().getCompletionEntryDetails(file, position, entryName, formattingOptions);
+                if (details) {
+                    const mappedCodeActions = map(details.codeActions, action => this.mapCodeAction(action, scriptInfo));
+                    return { ...details, codeActions: mappedCodeActions };
+                }
+                else {
+                    return undefined;
+                }
+            });
         }
 
         private getCompileOnSaveAffectedFileList(args: protocol.FileRequestArgs): ReadonlyArray<protocol.CompileOnSaveAffectedFileListSingleProject> {