Convert use-default-import refactor to a codefix

src/compiler/diagnosticMessages.json

@@ -3826,6 +3826,10 @@
         "category": "Suggestion",
         "code": 80002
     },
+    "Import may be converted to a default import.": {
+        "category": "Suggestion",
+        "code": 80003
+    },
 
     "Add missing 'super()' call": {
         "category": "Message",

src/services/codefixes/convertToEs6Module.ts

@@ -495,9 +495,13 @@ namespace ts.codefix {
             : makeImport(/*name*/ undefined, [makeImportSpecifier(propertyName, localName)], moduleSpecifier);
     }
 
-    function makeImport(name: Identifier | undefined, namedImports: ReadonlyArray<ImportSpecifier>, moduleSpecifier: string): ImportDeclaration {
+    function makeImport(name: Identifier | undefined, namedImports: ReadonlyArray<ImportSpecifier> | undefined, moduleSpecifier: string): ImportDeclaration {
+        return makeImportDeclaration(name, namedImports, createLiteral(moduleSpecifier));
+    }
+
+    export function makeImportDeclaration(name: Identifier, namedImports: ReadonlyArray<ImportSpecifier> | undefined, moduleSpecifier: Expression) {
         const importClause = (name || namedImports) && createImportClause(name, namedImports && createNamedImports(namedImports));
-        return createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, importClause, createLiteral(moduleSpecifier));
+        return createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, importClause, moduleSpecifier);
     }
 
     function makeImportSpecifier(propertyName: string | undefined, name: string): ImportSpecifier {

src/services/codefixes/fixInvalidImportSyntax.ts

@@ -26,12 +26,7 @@ namespace ts.codefix {
         const variations: CodeAction[] = [];
 
         // import Bluebird from "bluebird";
-        variations.push(createAction(context, sourceFile, node, createImportDeclaration(
-            /*decorators*/ undefined,
-            /*modifiers*/ undefined,
-            createImportClause(namespace.name, /*namedBindings*/ undefined),
-            node.moduleSpecifier
-        )));
+        variations.push(createAction(context, sourceFile, node, makeImportDeclaration(namespace.name, /*namedImports*/ undefined, node.moduleSpecifier)));
 
         if (getEmitModuleKind(opts) === ModuleKind.CommonJS) {
             // import Bluebird = require("bluebird");

src/services/codefixes/fixes.ts

@@ -20,3 +20,4 @@
 /// <reference path='inferFromUsage.ts' />
 /// <reference path="fixInvalidImportSyntax.ts" />
 /// <reference path="fixStrictClassInitialization.ts" />
+/// <reference path="useDefaultImport.ts" />

src/services/codefixes/useDefaultImport.ts

@@ -0,0 +1,43 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "useDefaultImport";
+    const errorCodes = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            const { sourceFile, span: { start } } = context;
+            const info = getInfo(sourceFile, start);
+            if (!info) return undefined;
+            const description = getLocaleSpecificMessage(Diagnostics.Convert_to_default_import);
+            const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, info));
+            return [{ description, changes, fixId }];
+        },
+        fixIds: [fixId],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+            const info = getInfo(diag.file!, diag.start!);
+            if (info) doChange(changes, diag.file!, info);
+        }),
+    });
+
+    interface Info {
+        readonly importNode: AnyImportSyntax;
+        readonly name: Identifier;
+        readonly moduleSpecifier: Expression;
+    }
+    function getInfo(sourceFile: SourceFile, pos: number): Info | undefined {
+        const name = getTokenAtPosition(sourceFile, pos, /*includeJsDocComment*/ false);
+        if (!isIdentifier(name)) return undefined; // bad input
+        const { parent } = name;
+        if (isImportEqualsDeclaration(parent) && isExternalModuleReference(parent.moduleReference)) {
+            return { importNode: parent, name, moduleSpecifier: parent.moduleReference.expression };
+        }
+        else if (isNamespaceImport(parent)) {
+            const importNode = parent.parent.parent;
+            return { importNode, name, moduleSpecifier: importNode.moduleSpecifier };
+        }
+    }
+
+    function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, info: Info): void {
+        changes.replaceNode(sourceFile, info.importNode, makeImportDeclaration(info.name, /*namedImports*/ undefined, info.moduleSpecifier));
+    }
+}

src/services/refactors/refactors.ts

@@ -1,3 +1,2 @@
 /// <reference path="annotateWithTypeFromJSDoc.ts" />
 /// <reference path="extractSymbol.ts" />
-/// <reference path="useDefaultImport.ts" />

src/services/suggestionDiagnostics.ts

@@ -25,6 +25,30 @@ namespace ts {
             check(sourceFile);
         }
 
+        if (getAllowSyntheticDefaultImports(program.getCompilerOptions())) {
+            for (const importNode of sourceFile.imports) {
+                const name = importNameForConvertToDefaultImport(importNode.parent);
+                if (!name) continue;
+                const module = getResolvedModule(sourceFile, importNode.text);
+                const resolvedFile = module && program.getSourceFile(module.resolvedFileName);
+                if (resolvedFile && resolvedFile.externalModuleIndicator && isExportAssignment(resolvedFile.externalModuleIndicator) && resolvedFile.externalModuleIndicator.isExportEquals) {
+                    diags.push(createDiagnosticForNode(name, Diagnostics.Import_may_be_converted_to_a_default_import));
+                }
+            }
+        }
+
         return diags.concat(checker.getSuggestionDiagnostics(sourceFile));
     }
+
+    function importNameForConvertToDefaultImport(node: Node): Identifier | undefined {
+        if (isExternalModuleReference(node)) {
+            return node.parent.name;
+        }
+        if (isImportDeclaration(node)) {
+            const { importClause, moduleSpecifier } = node;
+            return importClause && !importClause.name && importClause.namedBindings.kind === SyntaxKind.NamespaceImport && isStringLiteral(moduleSpecifier)
+                ? importClause.namedBindings.name
+                : undefined;
+        }
+    }
 }

tests/cases/fourslash/codeFixUseDefaultImport.ts

@@ -0,0 +1,39 @@
+/// <reference path='fourslash.ts' />
+
+// @allowSyntheticDefaultImports: true
+
+// @Filename: /a.d.ts
+////declare const x: number;
+////export = x;
+
+// @Filename: /b.ts
+////import * as [|a|] from "./a";
+
+// @Filename: /c.ts
+////import [|a|] = require("./a");
+
+// @Filename: /d.ts
+////import "./a";
+
+// @Filename: /e.ts
+////import * as n from "./non-existant";
+
+for (const file of ["/b.ts", "/c.ts"]) {
+    goTo.file(file);
+
+    verify.getSuggestionDiagnostics([{
+        message: "Import may be converted to a default import.",
+        range: test.ranges().find(r => r.fileName === file),
+        code: 80003,
+    }]);
+
+    verify.codeFix({
+        description: "Convert to default import",
+        newFileContent: `import a from "./a";`,
+    });
+}
+
+for (const file of ["/d.ts", "/e.ts"]) {
+    goTo.file(file);
+    verify.getSuggestionDiagnostics([]);
+}

tests/cases/fourslash/convertFunctionToEs6Class1.ts

@@ -13,7 +13,6 @@
 
 verify.getSuggestionDiagnostics([{
     message: "This constructor function may be converted to a class declaration.",
-    category: "suggestion",
     code: 80002,
 }]);
 

tests/cases/fourslash/refactorConvertToEs6Module_export_named.ts

@@ -9,7 +9,6 @@
 
 verify.getSuggestionDiagnostics([{
     message: "File is a CommonJS module; it may be converted to an ES6 module.",
-    category: "suggestion",
     code: 80001,
 }]);