Type-only default import checking

microsoft · DanielRosenwasser · Jan 3, 2020 · Nov 12, 2019 · Nov 13, 2019 · Nov 13, 2019
commit 558dd49fda8c145c8a3b3f164e3fc9e02e6d089c
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -2210,9 +2210,18 @@ namespace ts {
                 }
                 else if (hasSyntheticDefault) {
                     // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present
-                    return resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
+                    return maybeTypeOnly(
+                        resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) ||
+                        resolveSymbol(moduleSymbol, dontResolveAlias));
                 }
-                return exportDefaultSymbol;
+                return maybeTypeOnly(exportDefaultSymbol);
+            }
+
+            function maybeTypeOnly(symbol: Symbol | undefined) {
+                if (symbol && node.isTypeOnly && node.name) {
+                    return createSyntheticTypeAlias(node.name, symbol);
+                }
+                return symbol;
             }
         }
 
@@ -2345,12 +2354,13 @@ namespace ts {
          * `TypeFlags.Alias` so that alias resolution works as usual, but once the target `A`
          * has been resolved, we essentially want to pretend we have a type alias to that target.
          */
-        function createSyntheticTypeAlias(sourceNode: ExportSpecifier | ImportSpecifier, target: Symbol) {
+        function createSyntheticTypeAlias(sourceNode: ExportSpecifier | Identifier, target: Symbol) {
             if (!(target.flags & SymbolFlags.Type)) {
-                const nameText = idText(sourceNode.name);
+                const identifier = isExportSpecifier(sourceNode) ? sourceNode.name : sourceNode;
+                const nameText = idText(identifier);
                 addRelatedInfo(
                     error(
-                        sourceNode.name,
+                        identifier,
                         Diagnostics.Type_only_0_must_be_a_type_but_1_is_a_value,
                         isExportSpecifier(sourceNode) ? "export" : "import",
                         nameText),

diff --git a/tests/baselines/reference/importClause_default.errors.txt b/tests/baselines/reference/importClause_default.errors.txt
@@ -0,0 +1,13 @@
+/b.ts(2,5): error TS2693: 'A' only refers to a type, but is being used as a value here.
+
+
+==== /a.ts (0 errors) ====
+    export default class A {}
+
+==== /b.ts (1 errors) ====
+    import type A from './a';
+    new A();
+        ~
+!!! error TS2693: 'A' only refers to a type, but is being used as a value here.
+    let a: A;
+
diff --git a/tests/baselines/reference/importClause_default.js b/tests/baselines/reference/importClause_default.js
@@ -0,0 +1,25 @@
+//// [tests/cases/conformance/externalModules/typeOnly/importClause_default.ts] ////
+
+//// [a.ts]
+export default class A {}
+
+//// [b.ts]
+import type A from './a';
+new A();
+let a: A;
+
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+var A = /** @class */ (function () {
+    function A() {
+    }
+    return A;
+}());
+exports["default"] = A;
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+new A();
+var a;
diff --git a/tests/baselines/reference/importClause_default.symbols b/tests/baselines/reference/importClause_default.symbols
@@ -0,0 +1,13 @@
+=== /a.ts ===
+export default class A {}
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+=== /b.ts ===
+import type A from './a';
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
+new A();
+let a: A;
+>a : Symbol(a, Decl(b.ts, 2, 3))
+>A : Symbol(A, Decl(b.ts, 0, 6))
+
diff --git a/tests/baselines/reference/importClause_default.types b/tests/baselines/reference/importClause_default.types
@@ -0,0 +1,15 @@
+=== /a.ts ===
+export default class A {}
+>A : A
+
+=== /b.ts ===
+import type A from './a';
+>A : any
+
+new A();
+>new A() : any
+>A : any
+
+let a: A;
+>a : typeof import("/a").default
+