update typechecker to have errors on called imported namespaces and g…

…ood error recovery with a quickfix
Wesley Wigham (weswigham) · Jan 9, 2018 · Nov 1, 2017 · Nov 1, 2017 · Nov 1, 2017 · Nov 1, 2017
commit e9106036e5f087c9f8580f436b2bade891110142
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1846,8 +1846,34 @@ namespace ts {
         // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable).
         function resolveESModuleSymbol(moduleSymbol: Symbol, moduleReferenceExpression: Expression, dontResolveAlias: boolean): Symbol {
             const symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
-            if (!dontResolveAlias && symbol && !(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) {
-                error(moduleReferenceExpression, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol));
+            if (!dontResolveAlias && symbol) {
+                if (!(symbol.flags & (SymbolFlags.Module | SymbolFlags.Variable))) {
+                    error(moduleReferenceExpression, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol));
+                    return symbol;
+                }
+                const referenaceParent = moduleReferenceExpression.parent;
+                if (referenaceParent.kind === SyntaxKind.ImportDeclaration && getNamespaceDeclarationNode(referenaceParent as ImportDeclaration)) {
+                    const type = getTypeOfSymbol(symbol);
+                    let sigs = getSignaturesOfStructuredType(type, SignatureKind.Call);
+                    if (!sigs || !sigs.length) {
+                        sigs = getSignaturesOfStructuredType(type, SignatureKind.Construct);
+                    }
+                    if (sigs && sigs.length) {
+                        // Create a new symbol which has the module's type less the call and construct signatures
+                        const result = createSymbol(symbol.flags, symbol.escapedName);
+                        result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
+                        result.parent = symbol.parent;
+                        result.target = symbol;
+                        result.originatingImport = referenaceParent as ImportDeclaration;
+                        if (symbol.valueDeclaration) result.valueDeclaration = symbol.valueDeclaration;
+                        if (symbol.constEnumOnlyModule) result.constEnumOnlyModule = true;
+                        if (symbol.members) result.members = cloneMap(symbol.members);
+                        if (symbol.exports) result.exports = cloneMap(symbol.exports);
+                        const moduleType = resolveStructuredTypeMembers(type as StructuredType); // Should already be resolved from the signature checks above
+                        result.type = createAnonymousType(result, moduleType.members, emptyArray, emptyArray, moduleType.stringIndexInfo, moduleType.numberIndexInfo);
+                        return result;
+                    }
+                }
             }
             return symbol;
         }
@@ -8963,7 +8989,19 @@ namespace ts {
 
                 diagnostics.add(createDiagnosticForNodeFromMessageChain(errorNode, errorInfo));
             }
-            return result !== Ternary.False;
+            const answer = result !== Ternary.False;
+            // Check if we should issue an extra diagnostic to produce a quickfix for a slightly incorrect import statement
+            if (headMessage && errorNode && !answer && source.symbol) {
+                const links = getSymbolLinks(source.symbol);
+                if (links.originatingImport) {
+                    const helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, /*errorNode*/ undefined);
+                    if (helpfulRetry) {
+                        // Likely an incorrect import. Issue a helpful diagnostic to produce a quickfix to change the import
+                        diagnostics.add(createDiagnosticForNode(links.originatingImport, Diagnostics.Import_is_called_or_constructed_which_is_not_valid_ES2015_module_usage_and_will_fail_at_runtime));
+                    }
+                }
+            }
+            return answer;
 
             function reportError(message: DiagnosticMessage, arg0?: string, arg1?: string, arg2?: string): void {
                 Debug.assert(!!errorNode);
@@ -16618,7 +16656,7 @@ namespace ts {
                     error(node, Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
                 }
                 else {
-                    error(node, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures, typeToString(apparentType));
+                    invocationError(node, apparentType, SignatureKind.Call);
                 }
                 return resolveErrorCall(node);
             }
@@ -16720,7 +16758,7 @@ namespace ts {
                 return signature;
             }
 
-            error(node, Diagnostics.Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature);
+            invocationError(node, expressionType, SignatureKind.Construct);
             return resolveErrorCall(node);
         }
 
@@ -16767,6 +16805,22 @@ namespace ts {
             return true;
         }
 
+        function invocationError(node: Node, apparentType: Type, kind: SignatureKind) {
+            error(node, kind === SignatureKind.Call
+                ? Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures
+                : Diagnostics.Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature
+            , typeToString(apparentType));
+            invocationErrorRecovery(apparentType, kind);
+        }
+
+        function invocationErrorRecovery(apparentType: Type, kind: SignatureKind) {
+            if (apparentType.symbol && getSymbolLinks(apparentType.symbol).originatingImport) {
+                const sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind);
+                if (!sigs || !sigs.length) return;
+                error(getSymbolLinks(apparentType.symbol).originatingImport, Diagnostics.Import_is_called_or_constructed_which_is_not_valid_ES2015_module_usage_and_will_fail_at_runtime);
+            }
+        }
+
         function resolveTaggedTemplateExpression(node: TaggedTemplateExpression, candidatesOutArray: Signature[]): Signature {
             const tagType = checkExpression(node.tag);
             const apparentType = getApparentType(tagType);
@@ -16784,7 +16838,7 @@ namespace ts {
             }
 
             if (!callSignatures.length) {
-                error(node, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures, typeToString(apparentType));
+                invocationError(node, apparentType, SignatureKind.Call);
                 return resolveErrorCall(node);
             }
 
@@ -16841,6 +16895,7 @@ namespace ts {
                 errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures, typeToString(apparentType));
                 errorInfo = chainDiagnosticMessages(errorInfo, headMessage);
                 diagnostics.add(createDiagnosticForNodeFromMessageChain(node, errorInfo));
+                invocationErrorRecovery(apparentType, SignatureKind.Call);
                 return resolveErrorCall(node);
             }
 

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -3326,6 +3326,10 @@
         "category": "Message",
         "code": 6186
     },
+    "Import is called or constructed, which is not valid ES2015 module usage, and will fail at runtime.": {
+        "category": "Error",
+        "code": 7004
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005
@@ -3797,5 +3801,9 @@
     "Convert to default import": {
         "category": "Message",
         "code": 95013
+    },
+    "Replace import with '{0}'.": {
+        "category": "Message",
+        "code": 95014
     }
 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -3102,6 +3102,7 @@ namespace ts {
         bindingElement?: BindingElement;    // Binding element associated with property symbol
         exportsSomeValue?: boolean;         // True if module exports some value (not just types)
         enumKind?: EnumKind;                // Enum declaration classification
+        originatingImport?: ImportDeclaration; // Import declaration which produced the symbol, present if the symbol is poisoned
     }
 
     /* @internal */

diff --git a/src/services/codefixes/fixInvalidImportSyntax.ts b/src/services/codefixes/fixInvalidImportSyntax.ts
@@ -0,0 +1,52 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Import_is_called_or_constructed_which_is_not_valid_ES2015_module_usage_and_will_fail_at_runtime.code],
+        getCodeActions: getActionsForInvalidImport
+    });
+
+    function getActionsForInvalidImport(context: CodeFixContext): CodeAction[] | undefined {
+        const sourceFile = context.sourceFile;
+
+        // This is the whole import statement, eg:
+        // import * as Bluebird from 'bluebird';
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        const node = getTokenAtPosition(sourceFile, context.span.start, /*includeJsDocComment*/ false).parent as ImportDeclaration;
+        const namespace = getNamespaceDeclarationNode(node) as NamespaceImport;
+        const opts = context.program.getCompilerOptions();
+        const variations: CodeAction[] = [];
+        if (opts.module === ModuleKind.CommonJS || (!opts.module && opts.target < ScriptTarget.ES2015)) {
+            // import Bluebird = require("bluebird");
+            const replacement = createImportEqualsDeclaration(
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
+                namespace.name,
+                createExternalModuleReference(node.moduleSpecifier)
+            );
+            const changeTracker = textChanges.ChangeTracker.fromContext(context);
+            changeTracker.replaceNode(sourceFile, node, replacement, { useNonAdjustedEndPosition: true });
+            const changes = changeTracker.getChanges();
+            variations.push({
+                description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Replace_import_with_0), [changes[0].textChanges[0].newText]),
+                changes
+            });
+        }
+
+        // import Bluebird from "bluebird";
+        const replacement = createImportDeclaration(
+            /*decorators*/ undefined,
+            /*modifiers*/ undefined,
+            createImportClause(namespace.name, /*namedBindings*/ undefined),
+            node.moduleSpecifier
+        );
+        const changeTracker = textChanges.ChangeTracker.fromContext(context);
+        changeTracker.replaceNode(sourceFile, node, replacement, { useNonAdjustedEndPosition: true });
+        const changes = changeTracker.getChanges();
+        variations.push({
+            description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Replace_import_with_0), [changes[0].textChanges[0].newText]),
+            changes
+        });
+
+        return variations;
+    }
+}
diff --git a/src/services/codefixes/fixes.ts b/src/services/codefixes/fixes.ts
@@ -15,3 +15,5 @@
 /// <reference path='disableJsDiagnostics.ts' />
 /// <reference path='helpers.ts' />
 /// <reference path='inferFromUsage.ts' />
+/// <reference path="fixInvalidImportSyntax.ts" />
+
diff --git a/tests/baselines/reference/augmentExportEquals7.types b/tests/baselines/reference/augmentExportEquals7.types
@@ -10,7 +10,7 @@ export = lib;
 
 === /node_modules/@types/lib-extender/index.d.ts ===
 import * as lib from "lib";
->lib : () => void
+>lib : {}
 
 declare module "lib" {
     export function fn(): void;

diff --git a/tests/baselines/reference/es6ExportEqualsInterop.types b/tests/baselines/reference/es6ExportEqualsInterop.types
@@ -136,13 +136,13 @@ import * as y7 from "function";
 >y7 : () => any
 
 import * as y8 from "function-module";
->y8 : typeof z8
+>y8 : typeof y8
 
 import * as y9 from "class";
 >y9 : typeof z9
 
 import * as y0 from "class-module";
->y0 : typeof z0
+>y0 : typeof y0
 
 y1.a;
 >y1.a : any
@@ -181,7 +181,7 @@ y7.a;
 
 y8.a;
 >y8.a : number
->y8 : typeof z8
+>y8 : typeof y8
 >a : number
 
 y9.a;
@@ -191,7 +191,7 @@ y9.a;
 
 y0.a;
 >y0.a : number
->y0 : typeof z0
+>y0 : typeof y0
 >a : number
 
 // named import