fix(42605): make Convert default export to named export refactoring available for export default identifier

Author: Zuckjet

src/compiler/parser.ts

@@ -1823,7 +1823,7 @@ namespace ts {
         function nextTokenCanFollowDefaultKeyword(): boolean {
             nextToken();
             return token() === SyntaxKind.ClassKeyword || token() === SyntaxKind.FunctionKeyword ||
-                token() === SyntaxKind.InterfaceKeyword ||
+                token() === SyntaxKind.InterfaceKeyword || token() === SyntaxKind.Identifier ||
                 (token() === SyntaxKind.AbstractKeyword && lookAhead(nextTokenIsClassKeywordOnSameLine)) ||
                 (token() === SyntaxKind.AsyncKeyword && lookAhead(nextTokenIsFunctionKeywordOnSameLine));
         }
@@ -6182,6 +6182,9 @@ namespace ts {
                             return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
                     }
                 default:
+                    if ((token() === SyntaxKind.Identifier) && isExportDefaultModifiers(modifiers)) {
+                        return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
+                    }
                     if (decorators || modifiers) {
                         // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
                         // would follow. For recovery and error reporting purposes, return an incomplete declaration.
@@ -7134,7 +7137,9 @@ namespace ts {
                 isExportEquals = true;
             }
             else {
-                parseExpected(SyntaxKind.DefaultKeyword);
+                if (token() !== SyntaxKind.Identifier) {
+                    parseExpected(SyntaxKind.DefaultKeyword);
+                }
             }
             const expression = parseAssignmentExpressionOrHigher();
             parseSemicolon();

src/compiler/utilities.ts

@@ -4720,7 +4720,7 @@ namespace ts {
      * NOTE: This function does not use `parent` pointers and will not include modifiers from JSDoc.
      */
     export function getSyntacticModifierFlagsNoCache(node: Node): ModifierFlags {
-        let flags = modifiersToFlags(node.modifiers);
+        let flags = isExportAssignment(node) && isExportDefaultModifiers(node.modifiers) ? ModifierFlags.None : modifiersToFlags(node.modifiers);
         if (node.flags & NodeFlags.NestedNamespace || (node.kind === SyntaxKind.Identifier && (<Identifier>node).isInJSDocNamespace)) {
             flags |= ModifierFlags.Export;
         }
@@ -4820,6 +4820,15 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier || isPropertyAccessEntityNameExpression(node);
     }
 
+    export function isExportDefaultModifiers(modifiers: NodeArray<Modifier> | undefined): boolean{
+        return modifiers &&
+            modifiers.length === 2 &&
+            modifiers[0].kind === SyntaxKind.ExportKeyword &&
+            modifiers[1].kind === SyntaxKind.DefaultKeyword
+            ? true
+            : false;
+    }
+
     export function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
         switch (node.kind) {
             case SyntaxKind.Identifier:

src/services/findAllReferences.ts

@@ -1180,7 +1180,15 @@ namespace ts.FindAllReferences {
             for (const indirectUser of indirectUsers) {
                 for (const node of getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName)) {
                     // Import specifiers should be handled by importSearches
-                    if (isIdentifier(node) && !isImportOrExportSpecifier(node.parent) && checker.getSymbolAtLocation(node) === exportSymbol) {
+                    const symbol = checker.getSymbolAtLocation(node);
+                    const isExportDefaultIdentifier =
+                        symbol && symbol.declarations &&
+                        symbol.declarations[0] &&
+                        isExportAssignment(symbol.declarations[0]) &&
+                        isExportDefaultModifiers(
+                            symbol.declarations[0].modifiers
+                        );
+                    if (isIdentifier(node) && !isImportOrExportSpecifier(node.parent) && (symbol === exportSymbol || isExportDefaultIdentifier)) {
                         cb(node);
                     }
                 }

src/services/refactors/convertExport.ts

@@ -48,7 +48,7 @@ namespace ts.refactor {
     });
 
     // If a VariableStatement, will have exactly one VariableDeclaration, with an Identifier for a name.
-    type ExportToConvert = FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | EnumDeclaration | NamespaceDeclaration | TypeAliasDeclaration | VariableStatement;
+    type ExportToConvert = FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | EnumDeclaration | NamespaceDeclaration | TypeAliasDeclaration | VariableStatement | ExportAssignment;
     interface ExportInfo {
         readonly exportNode: ExportToConvert;
         readonly exportName: Identifier; // This is exportNode.name except for VariableStatement_s.
@@ -67,7 +67,7 @@ namespace ts.refactor {
 
         const exportingModuleSymbol = isSourceFile(exportNode.parent) ? exportNode.parent.symbol : exportNode.parent.parent.symbol;
 
-        const flags = getSyntacticModifierFlags(exportNode);
+        const flags = getSyntacticModifierFlags(exportNode) || (isExportDefaultModifiers(exportNode.modifiers) ? ModifierFlags.ExportDefault : ModifierFlags.None);
         const wasDefault = !!(flags & ModifierFlags.Default);
         // If source file already has a default export, don't offer refactor.
         if (!(flags & ModifierFlags.Export) || !wasDefault && exportingModuleSymbol.exports!.has(InternalSymbolName.Default)) {
@@ -95,6 +95,11 @@ namespace ts.refactor {
                 Debug.assert(!wasDefault, "Can't have a default flag here");
                 return isIdentifier(decl.name) ? { exportNode: vs, exportName: decl.name, wasDefault, exportingModuleSymbol } : undefined;
             }
+            case SyntaxKind.ExportAssignment: {
+                const node = exportNode as ExportAssignment;
+                const exp = node.expression as Identifier;
+                return { exportNode: node, exportName: exp, wasDefault, exportingModuleSymbol };
+            }
             default:
                 return undefined;
         }
@@ -108,6 +113,11 @@ namespace ts.refactor {
     function changeExport(exportingSourceFile: SourceFile, { wasDefault, exportNode, exportName }: ExportInfo, changes: textChanges.ChangeTracker, checker: TypeChecker): void {
         if (wasDefault) {
             changes.delete(exportingSourceFile, Debug.checkDefined(findModifier(exportNode, SyntaxKind.DefaultKeyword), "Should find a default keyword in modifier list"));
+            if (exportNode.kind === SyntaxKind.ExportAssignment) {
+                const exp = exportNode.expression as Identifier;
+                const spec = makeExportSpecifier(exp.text, exp.text);
+                changes.replaceNode(exportingSourceFile, exp, factory.createNamedExports([spec]));
+            }
         }
         else {
             const exportKeyword = Debug.checkDefined(findModifier(exportNode, SyntaxKind.ExportKeyword), "Should find an export keyword in modifier list");
@@ -134,7 +144,7 @@ namespace ts.refactor {
                     changes.insertNodeAfter(exportingSourceFile, exportNode, factory.createExportDefault(factory.createIdentifier(exportName.text)));
                     break;
                 default:
-                    Debug.assertNever(exportNode, `Unexpected exportNode kind ${(exportNode as ExportToConvert).kind}`);
+                    Debug.assertNever(exportNode as never, `Unexpected exportNode kind ${(exportNode as ExportToConvert).kind}`);
             }
         }
     }

tests/cases/fourslash/refactorConvertExport_defaultToNamed2.ts

@@ -0,0 +1,45 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////const f = () => {};
+/////*a*/export default f;/*b*/
+
+
+// @Filename: /b.ts
+////import f from "./a";
+////import { default as f } from "./a";
+////import { default as g } from "./a";
+////import f, * as a from "./a";
+////
+////export { default } from "./a";
+////export { default as f } from "./a";
+////export { default as i } from "./a";
+////
+////import * as a from "./a";
+////a.default();
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert export",
+    actionName: "Convert default export to named export",
+    actionDescription: "Convert default export to named export",
+    newContent: {
+        "/a.ts":
+`const f = () => {};
+export { f };`,
+
+        "/b.ts":
+`import { f } from "./a";
+import { f } from "./a";
+import { f as g } from "./a";
+import * as a from "./a";
+import { f } from "./a";
+
+export { f as default } from "./a";
+export { f } from "./a";
+export { f as i } from "./a";
+
+import * as a from "./a";
+a.f();`,
+},
+});