improve import code fixes for UMD modules

 - use default import under --allowSyntheticDefaultImports
 - import..require support
 - make make quick fix info match resulting import
 - make diagnostics

Author: aluanhaddad

src/compiler/diagnosticMessages.json

@@ -3781,5 +3781,13 @@
     "Infer parameter types from usage.": {
         "category": "Message",
         "code": 95012
+    },
+    "Import '{0}' = require(\"{1}\").": {
+        "category": "Message",
+        "code": 95013
+    },
+    "Import * as '{0}' from \"{1}\".": {
+        "category": "Message",
+        "code": 95014
     }
 }

src/services/codefixes/importFixes.ts

@@ -181,6 +181,7 @@ namespace ts.codefix {
         Named,
         Default,
         Namespace,
+        Equals
     }
 
     export function getCodeActionForImport(moduleSymbol: Symbol, context: ImportCodeFixOptions): ImportCodeAction[] {
@@ -212,7 +213,7 @@ namespace ts.codefix {
 
     function getNamespaceImportName(declaration: AnyImportSyntax): Identifier {
         if (declaration.kind === SyntaxKind.ImportDeclaration) {
-            const namedBindings = declaration.importClause && declaration.importClause.namedBindings;
+            const namedBindings = declaration.importClause && isImportClause(declaration.importClause) && declaration.importClause.namedBindings;
             return namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport ? namedBindings.name : undefined;
         }
         else {
@@ -237,6 +238,8 @@ namespace ts.codefix {
                 return parent as ImportDeclaration;
             case SyntaxKind.ExternalModuleReference:
                 return (parent as ExternalModuleReference).parent;
+            case SyntaxKind.ImportEqualsDeclaration:
+                return parent as ImportEqualsDeclaration;
             default:
                 Debug.assert(parent.kind === SyntaxKind.ExportDeclaration);
                 // Ignore these, can't add imports to them.
@@ -249,11 +252,19 @@ namespace ts.codefix {
         const lastImportDeclaration = findLast(sourceFile.statements, isAnyImportSyntax);
 
         const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier);
-        const importDecl = createImportDeclaration(
-            /*decorators*/ undefined,
-            /*modifiers*/ undefined,
-            createImportClauseOfKind(kind, symbolName),
-            createStringLiteralWithQuoteStyle(sourceFile, moduleSpecifierWithoutQuotes));
+        const quotedModuleSpecifier = createStringLiteralWithQuoteStyle(sourceFile, moduleSpecifierWithoutQuotes);
+        const importDecl = kind !== ImportKind.Equals
+            ? createImportDeclaration(
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
+                createImportClauseOfKind(kind, symbolName),
+                quotedModuleSpecifier)
+            : createImportEqualsDeclaration(
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
+                createIdentifier(symbolName),
+                createExternalModuleReference(quotedModuleSpecifier));
+
         const changes = ChangeTracker.with(context, changeTracker => {
             if (lastImportDeclaration) {
                 changeTracker.insertNodeAfter(sourceFile, lastImportDeclaration, importDecl, { suffix: newLineCharacter });
@@ -263,11 +274,17 @@ namespace ts.codefix {
             }
         });
 
+        const actionFormat = kind === ImportKind.Equals
+            ? Diagnostics.Import_0_require_1
+            : kind === ImportKind.Namespace
+                ? Diagnostics.Import_Asterisk_as_0_from_1
+                : Diagnostics.Import_0_from_1;
+
         // if this file doesn't have any import statements, insert an import statement and then insert a new line
         // between the only import statement and user code. Otherwise just insert the statement because chances
         // are there are already a new line seperating code and import statements.
         return createCodeAction(
-            Diagnostics.Import_0_from_1,
+            actionFormat,
             [symbolName, moduleSpecifierWithoutQuotes],
             changes,
             "NewImport",
@@ -282,7 +299,7 @@ namespace ts.codefix {
         return literal;
     }
 
-    function createImportClauseOfKind(kind: ImportKind, symbolName: string) {
+    function createImportClauseOfKind(kind: ImportKind.Default | ImportKind.Named | ImportKind.Namespace, symbolName: string) {
         const id = createIdentifier(symbolName);
         switch (kind) {
             case ImportKind.Default:
@@ -534,7 +551,7 @@ namespace ts.codefix {
         declarations: ReadonlyArray<AnyImportSyntax>): ImportCodeAction {
         const fromExistingImport = firstDefined(declarations, declaration => {
             if (declaration.kind === SyntaxKind.ImportDeclaration && declaration.importClause) {
-                const changes = tryUpdateExistingImport(ctx, declaration.importClause);
+                const changes = tryUpdateExistingImport(ctx, isImportClause(declaration.importClause) && declaration.importClause || undefined);
                 if (changes) {
                     const moduleSpecifierWithoutQuotes = stripQuotes(declaration.moduleSpecifier.getText());
                     return createCodeAction(
@@ -564,9 +581,10 @@ namespace ts.codefix {
         return expression && isStringLiteral(expression) ? expression.text : undefined;
     }
 
-    function tryUpdateExistingImport(context: SymbolContext & { kind: ImportKind }, importClause: ImportClause): FileTextChanges[] | undefined {
+    function tryUpdateExistingImport(context: SymbolContext & { kind: ImportKind }, importClause: ImportClause | ImportEqualsDeclaration): FileTextChanges[] | undefined {
         const { symbolName, sourceFile, kind } = context;
-        const { name, namedBindings } = importClause;
+        const { name } = importClause;
+        const { namedBindings } = importClause.kind !== SyntaxKind.ImportEqualsDeclaration && importClause;
         switch (kind) {
             case ImportKind.Default:
                 return name ? undefined : ChangeTracker.with(context, t =>
@@ -592,6 +610,9 @@ namespace ts.codefix {
                 return namedBindings ? undefined : ChangeTracker.with(context, t =>
                     t.replaceNode(sourceFile, importClause, createImportClause(name, createNamespaceImport(createIdentifier(symbolName)))));
 
+            case ImportKind.Equals:
+                return undefined;
+
             default:
                 Debug.assertNever(kind);
         }
@@ -644,6 +665,19 @@ namespace ts.codefix {
             Debug.fail("Either the symbol or the JSX namespace should be a UMD global if we got here");
         }
 
+        const { module, allowSyntheticDefaultImports } = context.compilerOptions;
+
+        // Prefer to import as a synthetic `default` if available.
+        if (allowSyntheticDefaultImports || module === ModuleKind.System && allowSyntheticDefaultImports !== false) {
+            return getCodeActionForImport(symbol, { ...context, symbolName, kind: ImportKind.Default });
+        }
+
+        // When a synthetic `default` is unavailable, use `import..require` if the module kind supports it.
+        if (module === ModuleKind.AMD || module === ModuleKind.CommonJS || module === ModuleKind.UMD) {
+            return getCodeActionForImport(symbol, { ...context, symbolName, kind: ImportKind.Equals });
+        }
+
+        // Fall back to `* as ns` style imports.
         return getCodeActionForImport(symbol, { ...context, symbolName, kind: ImportKind.Namespace });
     }