Feat#Provide a quick-fix for non-exported imports

src/compiler/diagnosticMessages.json

@@ -6598,7 +6598,14 @@
         "category": "Message",
         "code": 90058
     },
-
+    "Export '{0}' from module '{1}'": {
+        "category": "Message",
+        "code": 90059
+    },
+    "Add all missing exports": {
+        "category": "Message",
+        "code": 90060
+    },
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001

src/services/codefixes/fixImportNonExportedMember.ts

@@ -0,0 +1,229 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "importNonExportedMember";
+
+    const errorCodes = [
+        Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code,
+    ];
+
+    registerCodeFix({
+        errorCodes,
+
+        getCodeActions(context) {
+            const { sourceFile } = context;
+
+            const info = getInfo(sourceFile, context, context.span.start);
+
+            if (!info || info.originSourceFile.isDeclarationFile) {
+                return undefined;
+            }
+
+            const changes = textChanges.ChangeTracker.with(context, (t) =>
+                doChange(t, info.originSourceFile, info.node)
+            );
+
+            return [
+                createCodeFixAction(
+                    /*fixName*/ fixId,
+                    changes,
+                    /*description*/ [
+                        Diagnostics.Export_0_from_module_1,
+                        info.node.text,
+                        showModuleSpecifier(info.importDecl),
+                    ],
+                    fixId,
+                    /*fixAllDescription*/ Diagnostics.Add_all_missing_exports
+                ),
+            ];
+        },
+
+        fixIds: [fixId],
+
+        getAllCodeActions: (context) =>
+            codeFixAll(context, errorCodes, (changes, diag) => {
+                const info = getInfo(diag.file, context, diag.start);
+
+                if (info) {
+                    doChange(changes, info.originSourceFile, info.node);
+                }
+            }),
+    });
+
+    interface Info {
+        readonly node: Identifier;
+
+        readonly importDecl: ImportDeclaration;
+
+        readonly originSourceFile: SourceFile;
+    }
+
+    function getInfo(
+        sourceFile: SourceFile,
+        context: CodeFixContext | CodeFixAllContext,
+        pos: number
+    ): Info | undefined {
+        const node = getTokenAtPosition(sourceFile, pos);
+
+        if (!isIdentifier(node)) {
+            return;
+        }
+
+        const importDecl = findAncestor(node, isImportDeclaration);
+
+        if (!importDecl || !isStringLiteralLike(importDecl.moduleSpecifier)) {
+            return undefined;
+        }
+
+        const resolvedModule = getResolvedModule(
+            sourceFile,
+            /*moduleName*/ importDecl.moduleSpecifier.text,
+            /*mode*/ undefined
+        );
+
+        if (!resolvedModule) {
+            return undefined;
+        }
+
+        const originSourceFile = context.program.getSourceFile(
+            resolvedModule.resolvedFileName
+        );
+
+        if (!originSourceFile) {
+            return undefined;
+        }
+
+        return { node, importDecl, originSourceFile };
+    }
+
+    function getNamedExportDeclaration(
+        sourceFile: SourceFile
+    ): ExportDeclaration | undefined {
+        let namedExport;
+
+        for (const statement of sourceFile.statements) {
+            if (
+                isExportDeclaration(statement) &&
+                statement.exportClause &&
+                isNamedExports(statement.exportClause)
+            ) {
+                namedExport = statement;
+            }
+        }
+
+        return namedExport;
+    }
+
+    function compareIdentifiers(s1: Identifier, s2: Identifier) {
+        return compareStringsCaseInsensitive(s1.text, s2.text);
+    }
+
+    function sortSpecifiers(
+        specifiers: ExportSpecifier[]
+    ): readonly ExportSpecifier[] {
+        return stableSort(specifiers, (s1, s2) =>
+            compareIdentifiers(
+                s1.propertyName || s1.name,
+                s2.propertyName || s2.name
+            )
+        );
+    }
+
+    const isVariableDeclarationListWith1Element = (
+        node: Node
+    ): node is VariableDeclarationList =>
+        !(isVariableDeclarationList(node) && node.declarations.length !== 1);
+
+    function doChange(
+        changes: textChanges.ChangeTracker,
+        sourceFile: SourceFile,
+        node: Identifier
+    ): void {
+        const moduleSymbol = sourceFile.localSymbol ?? sourceFile.symbol;
+
+        const localSymbol = moduleSymbol.valueDeclaration?.locals?.get(
+            node.escapedText
+        );
+
+        if (localSymbol === undefined) {
+            return;
+        }
+
+        // Node we need to export is a function
+        if (isFunctionSymbol(localSymbol)) {
+            const node = localSymbol.valueDeclaration;
+
+            if (node === undefined) {
+                return;
+            }
+
+            if (!isDeclarationStatement(node) && !isVariableStatement(node)) {
+                return;
+            }
+
+            return changes.insertExportModifier(sourceFile, node);
+        }
+        // Node we need to export is a variable declaration
+        else if (
+            localSymbol.valueDeclaration &&
+            isVariableDeclarationListWith1Element(
+                localSymbol.valueDeclaration.parent
+            )
+        ) {
+            const node = localSymbol.valueDeclaration.parent;
+
+            return changes.insertExportModifier(sourceFile, node);
+        }
+
+        // In all other cases => the node is a variable, and should be exported via `export {a}`
+        const namedExportDeclaration = getNamedExportDeclaration(sourceFile);
+
+        // If there is an existing export
+        if (
+            namedExportDeclaration?.exportClause &&
+            isNamedExports(namedExportDeclaration.exportClause)
+        ) {
+            return changes.replaceNode(
+                sourceFile,
+                namedExportDeclaration,
+                factory.updateExportDeclaration(
+                    /*node*/ namedExportDeclaration,
+                    /*modifiers*/ undefined,
+                    /*isTypeOnly*/ false,
+                    /*exportClause*/ factory.updateNamedExports(
+                        /*node*/ namedExportDeclaration.exportClause,
+                        /*elements*/ sortSpecifiers(
+                            namedExportDeclaration.exportClause.elements.concat(
+                                factory.createExportSpecifier(
+                                    /*isTypeOnly*/ false,
+                                    /*propertyName*/ undefined,
+                                    node
+                                )
+                            )
+                        )
+                    ),
+                    /*moduleSpecifier*/ undefined,
+                    /*assertClause*/ undefined
+                )
+            );
+        }
+        // There is no existing export
+        else {
+            return changes.insertNodeAtEndOfScope(
+                sourceFile,
+                sourceFile,
+                factory.createExportDeclaration(
+                    /*modifiers*/ undefined,
+                    /*isTypeOnly*/ false,
+                    /*exportClause*/ factory.createNamedExports([
+                        factory.createExportSpecifier(
+                            /*isTypeOnly*/ false,
+                            /*propertyName*/ undefined,
+                            node
+                        ),
+                    ]),
+                    /*moduleSpecifier*/ undefined
+                )
+            );
+        }
+    }
+}

src/services/textChanges.ts

@@ -780,8 +780,20 @@ namespace ts.textChanges {
             }
         }
 
-        public insertExportModifier(sourceFile: SourceFile, node: DeclarationStatement | VariableStatement): void {
-            this.insertText(sourceFile, node.getStart(sourceFile), "export ");
+        public insertExportModifier(
+            sourceFile: SourceFile,
+            node: DeclarationStatement | VariableStatement | VariableDeclarationList
+        ): void {
+            Debug.assert(
+                /*expression*/ !(isVariableDeclarationList(node) && node.declarations.length !== 1),
+                /*message*/ "Only allow adding export modifier to variable lists with 1 element"
+            );
+
+            this.insertText(
+                sourceFile,
+                node.getStart(sourceFile, /*includeJsDocComment*/ false),
+                "export "
+            );
         }
 
         public insertImportSpecifierAtIndex(sourceFile: SourceFile, importSpecifier: ImportSpecifier, namedImports: NamedImports, index: number) {

src/services/tsconfig.json

@@ -115,6 +115,7 @@
         "codefixes/convertConstToLet.ts",
         "codefixes/fixExpectedComma.ts",
         "codefixes/fixAddVoidToPromise.ts",
+        "codefixes/fixImportNonExportedMember.ts",
         "refactors/convertExport.ts",
         "refactors/convertImport.ts",
         "refactors/convertToOptionalChainExpression.ts",
@@ -134,6 +135,6 @@
         "transform.ts",
         "shims.ts",
         "globalThisShim.ts",
-        "exportAsModule.ts"
+        "exportAsModule.ts",
     ]
 }

tests/cases/fourslash/codeFixImportNonExportedMember1.ts

@@ -0,0 +1,29 @@
+/// <reference path='fourslash.ts' />
+// @Filename: /a.ts
+////declare function zoo(): any;
+////export { zoo };
+
+// @Filename: /b.ts
+////declare function foo(): any;
+////function bar(): any;
+////export { foo };
+
+// @Filename: /c.ts
+////import { zoo } from "./a";
+////import { bar } from "./b";
+
+goTo.file("/c.ts");
+verify.codeFixAvailable([
+  { description: `Export 'bar' from module './b'` },
+  { description: `Remove import from './a'` },
+  { description: `Remove import from './b'` },
+]);
+verify.codeFix({
+  index: 0,
+  description: `Export 'bar' from module './b'`,
+  newFileContent: {
+    "/b.ts": `declare function foo(): any;
+export function bar(): any;
+export { foo };`,
+  },
+});

tests/cases/fourslash/codeFixImportNonExportedMember2.ts

@@ -0,0 +1,45 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////let a = 1, b = 2, c = 3;
+////export function whatever() {
+////}
+
+// @Filename: /b.ts
+////let d = 4;
+////export function whatever2() {
+////}
+
+// @Filename: /c.ts
+////import { a } from "./a"
+////import { d } from "./b"
+
+goTo.file("/c.ts");
+verify.codeFixAvailable([
+  { description: `Export 'a' from module './a'` },
+  { description: `Export 'd' from module './b'` },
+  { description: `Remove import from './a'` },
+  { description: `Remove import from './b'` },
+]);
+verify.codeFix({
+  index: 0,
+  description: `Export 'a' from module './a'`,
+  newFileContent: {
+    "/a.ts": `let a = 1, b = 2, c = 3;
+export function whatever() {
+}
+
+export { a };
+`,
+  },
+});
+
+verify.codeFix({
+  index: 1,
+  description: `Export 'd' from module './b'`,
+  newFileContent: {
+    "/b.ts": `export let d = 4;
+export function whatever2() {
+}`,
+  },
+});

tests/cases/fourslash/codeFixImportNonExportedMember3.ts

@@ -0,0 +1,27 @@
+/// <reference path='fourslash.ts' />
+// @Filename: /a.ts
+////let a = 1, b = 2, c = 3;
+////let d = 4;
+////export function whatever() {
+////}
+////export { d }
+
+// @Filename: /b.ts
+////import { a, d } from "./a"
+
+goTo.file("/b.ts");
+verify.codeFixAvailable([
+  { description: `Export 'a' from module './a'` },
+  { description: `Remove import from './a'` },
+]);
+verify.codeFix({
+  index: 0,
+  description: `Export 'a' from module './a'`,
+  newFileContent: {
+    "/a.ts": `let a = 1, b = 2, c = 3;
+let d = 4;
+export function whatever() {
+}
+export { a, d };`,
+  },
+});

tests/cases/fourslash/codeFixImportNonExportedMember4.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+// @Filename: /node_modules/foo/index.d.ts
+////let a = 0
+////module.exports = 0;
+
+// @Filename: /a.ts
+////import { a } from "foo";
+
+verify.not.codeFixAvailable();