Change 'if' in combined switch case to two separate cases (#28444)

Author: Andy

src/services/refactors/convertExport.ts

@@ -166,38 +166,35 @@ namespace ts.refactor {
     }
 
     function changeNamedToDefaultImport(importingSourceFile: SourceFile, ref: Identifier, changes: textChanges.ChangeTracker): void {
-        const { parent } = ref;
+        const parent = ref.parent as PropertyAccessExpression | ImportSpecifier | ExportSpecifier;
         switch (parent.kind) {
             case SyntaxKind.PropertyAccessExpression:
                 // `a.foo` --> `a.default`
                 changes.replaceNode(importingSourceFile, ref, createIdentifier("default"));
                 break;
-            case SyntaxKind.ImportSpecifier:
-            case SyntaxKind.ExportSpecifier: {
-                const spec = parent as ImportSpecifier | ExportSpecifier;
-                if (spec.kind === SyntaxKind.ImportSpecifier) {
-                    // `import { foo } from "./a";` --> `import foo from "./a";`
-                    // `import { foo as bar } from "./a";` --> `import bar from "./a";`
-                    const defaultImport = createIdentifier(spec.name.text);
-                    if (spec.parent.elements.length === 1) {
-                        changes.replaceNode(importingSourceFile, spec.parent, defaultImport);
-                    }
-                    else {
-                        changes.delete(importingSourceFile, spec);
-                        changes.insertNodeBefore(importingSourceFile, spec.parent, defaultImport);
-                    }
+            case SyntaxKind.ImportSpecifier: {
+                // `import { foo } from "./a";` --> `import foo from "./a";`
+                // `import { foo as bar } from "./a";` --> `import bar from "./a";`
+                const defaultImport = createIdentifier(parent.name.text);
+                if (parent.parent.elements.length === 1) {
+                    changes.replaceNode(importingSourceFile, parent.parent, defaultImport);
                 }
                 else {
-                    // `export { foo } from "./a";` --> `export { default as foo } from "./a";`
-                    // `export { foo as bar } from "./a";` --> `export { default as bar } from "./a";`
-                    // `export { foo as default } from "./a";` --> `export { default } from "./a";`
-                    // (Because `export foo from "./a";` isn't valid syntax.)
-                    changes.replaceNode(importingSourceFile, spec, makeExportSpecifier("default", spec.name.text));
+                    changes.delete(importingSourceFile, parent);
+                    changes.insertNodeBefore(importingSourceFile, parent.parent, defaultImport);
                 }
                 break;
             }
+            case SyntaxKind.ExportSpecifier: {
+                // `export { foo } from "./a";` --> `export { default as foo } from "./a";`
+                // `export { foo as bar } from "./a";` --> `export { default as bar } from "./a";`
+                // `export { foo as default } from "./a";` --> `export { default } from "./a";`
+                // (Because `export foo from "./a";` isn't valid syntax.)
+                changes.replaceNode(importingSourceFile, parent, makeExportSpecifier("default", parent.name.text));
+                break;
+            }
             default:
-                Debug.failBadSyntaxKind(parent);
+                Debug.assertNever(parent);
         }
 
     }