Improve handling of module.exports = require("...")

Author: Andy Hanson

src/compiler/utilities.ts

@@ -4,6 +4,7 @@
 namespace ts {
     export const emptyArray: never[] = [] as never[];
     export const emptyMap: ReadonlyMap<never> = createMap<never>();
+    export const emptyUnderscoreEscapedMap: ReadonlyUnderscoreEscapedMap<never> = emptyMap as ReadonlyUnderscoreEscapedMap<never>;
 
     export const externalHelpersModuleNameText = "tslib";
 

src/services/refactors/convertToEs6Module.ts

@@ -187,7 +187,7 @@ namespace ts.refactor {
                     }
                     case SyntaxKind.BinaryExpression: {
                         const { left, operatorToken, right } = expression as BinaryExpression;
-                        return operatorToken.kind === SyntaxKind.EqualsToken && convertAssignment(sourceFile, statement as ExpressionStatement, left, right, changes, newLine, exports);
+                        return operatorToken.kind === SyntaxKind.EqualsToken && convertAssignment(sourceFile, checker, statement as ExpressionStatement, left, right, changes, newLine, exports);
                     }
                 }
             }
@@ -248,6 +248,7 @@ namespace ts.refactor {
 
     function convertAssignment(
         sourceFile: SourceFile,
+        checker: TypeChecker,
         statement: ExpressionStatement,
         left: Expression,
         right: Expression,
@@ -268,7 +269,7 @@ namespace ts.refactor {
                 let newNodes = isObjectLiteralExpression(right) ? tryChangeModuleExportsObject(right) : undefined;
                 let changedToDefaultExport = false;
                 if (!newNodes) {
-                    ([newNodes, changedToDefaultExport] = convertModuleExportsToExportDefault(right));
+                    ([newNodes, changedToDefaultExport] = convertModuleExportsToExportDefault(right, checker));
                 }
                 changes.replaceNodeWithNodes(sourceFile, statement, newNodes, { nodeSeparator: newLine, useNonAdjustedEndPosition: true });
                 return changedToDefaultExport;
@@ -336,7 +337,7 @@ namespace ts.refactor {
         }
     }
 
-    function convertModuleExportsToExportDefault(exported: Expression): [ReadonlyArray<Statement>, ModuleExportsChanged] {
+    function convertModuleExportsToExportDefault(exported: Expression, checker: TypeChecker): [ReadonlyArray<Statement>, ModuleExportsChanged] {
         const modifiers = [createToken(SyntaxKind.ExportKeyword), createToken(SyntaxKind.DefaultKeyword)];
         switch (exported.kind) {
             case SyntaxKind.FunctionExpression:
@@ -351,14 +352,8 @@ namespace ts.refactor {
                 return [[classExpressionToDeclaration(cls.name && cls.name.text, modifiers, cls)], true];
             }
             case SyntaxKind.CallExpression:
-                if (isRequireCall(exported, /*checkArguementIsStringLiteral*/ true)) {
-                    // `module.exports = require("x");` ==> `export * from "x"; export { default } from "x";`
-                    const moduleSpecifier = exported.arguments[0].text;
-                    const newNodes = [
-                        makeExportDeclaration(/*exportClause*/ undefined, moduleSpecifier),
-                        makeExportDeclaration([createExportSpecifier(/*propertyName*/ undefined, "default")], moduleSpecifier),
-                    ];
-                    return [newNodes, false];
+                if (isRequireCall(exported, /*checkArgumentIsStringLiteral*/ true)) {
+                    return convertReExportAll(exported.arguments[0], checker);
                 }
                 // falls through
             default:
@@ -367,6 +362,25 @@ namespace ts.refactor {
         }
     }
 
+    function convertReExportAll(reExported: StringLiteralLike, checker: TypeChecker): [ReadonlyArray<Statement>, ModuleExportsChanged] {
+        // `module.exports = require("x");` ==> `export * from "x"; export { default } from "x";`
+        const moduleSpecifier = reExported.text;
+        const moduleSymbol = checker.getSymbolAtLocation(reExported);
+        const exports = moduleSymbol ? moduleSymbol.exports : emptyUnderscoreEscapedMap;
+        return exports.has("export=" as __String)
+            ? [[reExportDefault(moduleSpecifier)], true]
+            : !exports.has("default" as __String)
+            ? [[reExportStar(moduleSpecifier)], false]
+            // If there's some non-default export, must include both `export *` and `export default`.
+            : exports.size > 1 ? [[reExportStar(moduleSpecifier), reExportDefault(moduleSpecifier)], true] : [[reExportDefault(moduleSpecifier)], true];
+    }
+    function reExportStar(moduleSpecifier: string): ExportDeclaration {
+        return makeExportDeclaration(/*exportClause*/ undefined, moduleSpecifier);
+    }
+    function reExportDefault(moduleSpecifier: string): ExportDeclaration {
+        return makeExportDeclaration([createExportSpecifier(/*propertyName*/ undefined, "default")], moduleSpecifier);
+    }
+
     function convertExportsDotXEquals(name: string | undefined, exported: Expression): Statement {
         const modifiers = [createToken(SyntaxKind.ExportKeyword)];
         switch (exported.kind) {

tests/cases/fourslash/refactorConvertToEs6Module_export_moduleDotExports.ts

@@ -8,8 +8,8 @@
 ////module.exports = class {}
 ////module.exports = class C {}
 ////module.exports = 0;
-////
-////module.exports = require("./b");
+
+// See also `refactorConvertToEs6Module_export_moduleDotExportsEqualsRequire.ts`
 
 goTo.select("a", "b");
 edit.applyRefactor({
@@ -23,7 +23,4 @@ export default class {
 export default class C {
 }
 export default 0;
-
-export * from "./b";
-export { default } from "./b";`,
 });

tests/cases/fourslash/refactorConvertToEs6Module_export_moduleDotExportsEqualsRequire.ts

@@ -0,0 +1,43 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+
+// @Filename: /a.d.ts
+////export const x: number;
+
+// @Filename: /b.d.ts
+////export default function f() {}
+
+// @Filename: /c.d.ts
+////export default function f(): void;
+////export function g(): void;
+
+// @Filename: /d.ts
+////declare const x: number;
+////export = x;
+
+// @Filename: /z.js
+// Normally -- just `export *`
+/////*a*/module/*b*/.exports = require("./a");
+// If just a default is exported, just `export { default }`
+////module.exports = require("./b");
+// May need both
+////module.exports = require("./c");
+// For `export =` re-export the "default" since that's what it will be converted to.
+////module.exports = require("./d");
+// In untyped case just go with `export *`
+////module.exports = require("./unknown");
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to ES6 module",
+    actionName: "Convert to ES6 module",
+    actionDescription: "Convert to ES6 module",
+    newContent:
+`export * from "./a";
+export { default } from "./b";
+export * from "./c";
+export { default } from "./c";
+export { default } from "./d";
+export * from "./unknown";`,
+});