Feat#Provide a quickfix for non-exported types

src/compiler/diagnosticMessages.json

@@ -5185,6 +5185,14 @@
         "category": "Message",
         "code": 90053
     },
+    "Export '{0}' from module '{1}'": {
+        "category": "Message",
+        "code": 90054
+    },
+    "Export all non-exported member": {
+        "category": "Message",
+        "code": 90055
+    },
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001

src/services/codefixes/fixImportNonExportedMember.ts

@@ -0,0 +1,103 @@
+/* @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(fixId, changes, [Diagnostics.Export_0_from_module_1, info.node.text, showModuleSpecifier(info.importDecl)], fixId, Diagnostics.Export_all_non_exported_member)];
+        },
+        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 (node && isIdentifier(node)) {
+            const importDecl = findAncestor(node, isImportDeclaration);
+            if (!importDecl || !isStringLiteralLike(importDecl.moduleSpecifier)) {
+                return undefined;
+            }
+            const resolvedModule = getResolvedModule(sourceFile, importDecl.moduleSpecifier.text);
+            const originSourceFile = resolvedModule && context.program.getSourceFile(resolvedModule.resolvedFileName);
+            if (!originSourceFile) {
+                return undefined;
+            }
+            return { node, importDecl, originSourceFile };
+        }
+    }
+
+    function isImportDeclaration(node: Node): node is ImportDeclaration {
+        return node.kind === SyntaxKind.ImportDeclaration;
+    }
+
+    function getNamedExportDeclaration(moduleSymbol: Symbol): ExportDeclaration | undefined {
+        let namedExport;
+        moduleSymbol.exports?.forEach((symbol) => {
+            const specifier = symbol.declarations[0];
+            if(specifier && isExportSpecifier(specifier) && isNamedExports(specifier.parent)) {
+                namedExport = specifier.parent?.parent;
+            }
+        });
+        return namedExport;
+    }
+
+    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) {
+            return;
+        }
+        if(isFunctionSymbol(localSymbol)) {
+            const start = localSymbol.valueDeclaration.pos;
+            changes.insertExportModifierAtPos(sourceFile, start? start+1:0);
+            return;
+        }
+
+        const current: VariableDeclarationList | Node = localSymbol.valueDeclaration.parent;
+        if(isVariableDeclarationList(current) && current.declarations.length <= 1) {
+            const start = localSymbol.valueDeclaration.parent.pos;
+            changes.insertExportModifierAtPos(sourceFile, start? start+1:0);
+            return;
+        }
+
+        const namedExportDeclaration = getNamedExportDeclaration(moduleSymbol);
+        let exportDeclaration;
+        const exportSpecifier = createExportSpecifier(/*propertyName*/ undefined, node);
+        if(namedExportDeclaration?.exportClause && isNamedExports(namedExportDeclaration.exportClause)) {
+            exportDeclaration = updateExportDeclaration(
+                namedExportDeclaration,
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
+                updateNamedExports(namedExportDeclaration.exportClause, namedExportDeclaration.exportClause.elements.concat(exportSpecifier)),
+                /*moduleSpecifier*/ undefined,
+                /*isTypeOnly*/ false);
+            changes.replaceNode(sourceFile, namedExportDeclaration, exportDeclaration);
+            return;
+        }
+        exportDeclaration = createExportDeclaration(
+            /*decorators*/ undefined,
+            /*modifiers*/ undefined,
+            createNamedExports([exportSpecifier]),
+            /*moduleSpecifier*/ undefined,
+            /*isTypeOnly*/ false);
+        changes.insertNodeAtEndOfScope(sourceFile, sourceFile, exportDeclaration);
+    }
+}

src/services/textChanges.ts

@@ -665,7 +665,11 @@ namespace ts.textChanges {
         }
 
         public insertExportModifier(sourceFile: SourceFile, node: DeclarationStatement | VariableStatement): void {
-            this.insertText(sourceFile, node.getStart(sourceFile), "export ");
+            this.insertExportModifierAtPos(sourceFile, node.getStart(sourceFile));
+        }
+
+        public insertExportModifierAtPos(sourceFile: SourceFile, position: number): void {
+            this.insertText(sourceFile, position, "export ");
         }
 
         /**

src/services/tsconfig.json

@@ -77,6 +77,7 @@
         "codefixes/fixModuleAndTargetOptions.ts",
         "codefixes/fixExtendsInterfaceBecomesImplements.ts",
         "codefixes/fixForgottenThisPropertyAccess.ts",
+        "codefixes/fixImportNonExportedMember.ts",
         "codefixes/fixInvalidJsxCharacters.ts",
         "codefixes/fixUnusedIdentifier.ts",
         "codefixes/fixUnreachableCode.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 { d, a };`
+    }
+});

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();

tests/cases/fourslash/codeFixImportNonExportedMember_all.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////declare function foo(): any;
+////declare function bar(): any;
+////declare function zoo(): any;
+////export { zoo }
+
+// @Filename: /b.ts
+////import { foo, bar } from "./a";
+
+goTo.file("/b.ts");
+verify.codeFixAll({
+    fixId: "importNonExportedMember",
+    fixAllDescription: ts.Diagnostics.Export_all_non_exported_member.message,
+    newFileContent: {
+        '/a.ts': `export declare function foo(): any;
+export declare function bar(): any;
+declare function zoo(): any;
+export { zoo }`
+    }
+});