Type-only auto imports

src/compiler/checker.ts

@@ -1869,12 +1869,7 @@ namespace ts {
         }
 
         function checkSymbolUsageInExpressionContext(symbol: Symbol, name: __String, useSite: Node) {
-            if (
-                !(useSite.flags & NodeFlags.Ambient) &&
-                !isPartOfTypeQuery(useSite) &&
-                !isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) &&
-                isExpressionNode(useSite)
-            ) {
+            if (!isValidTypeOnlyAliasUseSite(useSite)) {
                 const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);
                 if (typeOnlyDeclaration) {
                     const message = typeOnlyDeclaration.kind === SyntaxKind.ExportSpecifier

src/compiler/utilities.ts

@@ -6134,4 +6134,11 @@ namespace ts {
     export function pseudoBigIntToString({negative, base10Value}: PseudoBigInt): string {
         return (negative && base10Value !== "0" ? "-" : "") + base10Value;
     }
+
+    export function isValidTypeOnlyAliasUseSite(useSite: Node): boolean {
+        return !!(useSite.flags & NodeFlags.Ambient)
+            || isPartOfTypeQuery(useSite)
+            || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite)
+            || !isExpressionNode(useSite);
+    }
 }

src/services/completions.ts

@@ -525,6 +525,7 @@ namespace ts.Completions {
         symbolToOriginInfoMap: SymbolOriginInfoMap;
         previousToken: Node | undefined;
         readonly isJsxInitializer: IsJsxInitializer;
+        readonly isTypeOnlyLocation: boolean;
     }
     function getSymbolCompletionFromEntryId(
         program: Program,
@@ -543,7 +544,7 @@ namespace ts.Completions {
             return { type: "request", request: completionData };
         }
 
-        const { symbols, literals, location, completionKind, symbolToOriginInfoMap, previousToken, isJsxInitializer } = completionData;
+        const { symbols, literals, location, completionKind, symbolToOriginInfoMap, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
 
         const literal = find(literals, l => completionNameForLiteral(l) === entryId.name);
         if (literal !== undefined) return { type: "literal", literal };
@@ -556,7 +557,7 @@ namespace ts.Completions {
             const origin = symbolToOriginInfoMap[getSymbolId(symbol)];
             const info = getCompletionEntryDisplayNameForSymbol(symbol, compilerOptions.target!, origin, completionKind);
             return info && info.name === entryId.name && getSourceFromOrigin(origin) === entryId.source
-                ? { type: "symbol" as const, symbol, location, symbolToOriginInfoMap, previousToken, isJsxInitializer }
+                ? { type: "symbol" as const, symbol, location, symbolToOriginInfoMap, previousToken, isJsxInitializer, isTypeOnlyLocation }
                 : undefined;
         }) || { type: "none" };
     }
@@ -714,6 +715,7 @@ namespace ts.Completions {
         readonly isJsxInitializer: IsJsxInitializer;
         readonly insideJsDocTagTypeExpression: boolean;
         readonly symbolToSortTextMap: SymbolSortTextMap;
+        readonly isTypeOnlyLocation: boolean;
     }
     type Request = { readonly kind: CompletionDataKind.JsDocTagName | CompletionDataKind.JsDocTag } | { readonly kind: CompletionDataKind.JsDocParameterName, tag: JSDocParameterTag };
 
@@ -1012,6 +1014,7 @@ namespace ts.Completions {
         const symbolToOriginInfoMap: SymbolOriginInfoMap = [];
         const symbolToSortTextMap: SymbolSortTextMap = [];
         const importSuggestionsCache = host.getImportSuggestionsCache && host.getImportSuggestionsCache();
+        const isTypeOnly = isTypeOnlyCompletion();
 
         if (isRightOfDot || isRightOfQuestionDot) {
             getTypeScriptMemberSymbols();
@@ -1061,7 +1064,8 @@ namespace ts.Completions {
             previousToken,
             isJsxInitializer,
             insideJsDocTagTypeExpression,
-            symbolToSortTextMap
+            symbolToSortTextMap,
+            isTypeOnlyLocation: isTypeOnly
         };
 
         type JSDocTagWithTypeExpression = JSDocParameterTag | JSDocPropertyTag | JSDocReturnTag | JSDocTypeTag | JSDocTypedefTag;
@@ -1329,7 +1333,6 @@ namespace ts.Completions {
             const scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
             isInSnippetScope = isSnippetScope(scopeNode);
 
-            const isTypeOnly = isTypeOnlyCompletion();
             const symbolMeanings = (isTypeOnly ? SymbolFlags.None : SymbolFlags.Value) | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias;
 
             symbols = Debug.assertEachDefined(typeChecker.getSymbolsInScope(scopeNode, symbolMeanings), "getSymbolsInScope() should all be defined");

src/services/utilities.ts

@@ -1306,6 +1306,10 @@ namespace ts {
         return contains(typeKeywords, kind);
     }
 
+    export function isTypeKeywordToken(node: Node): node is Token<SyntaxKind.TypeKeyword> {
+        return node.kind === SyntaxKind.TypeKeyword;
+    }
+
     /** True if the symbol is for an external module, as opposed to a namespace. */
     export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean {
         return !!(moduleSymbol.flags & SymbolFlags.Module) && moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote;
@@ -1494,6 +1498,11 @@ namespace ts {
         }
     }
 
+    export function getTypeKeywordOfTypeOnlyImport(importClause: ImportClause, sourceFile: SourceFile): Token<SyntaxKind.TypeKeyword> {
+        Debug.assert(importClause.isTypeOnly);
+        return cast(importClause.getChildAt(0, sourceFile), isTypeKeywordToken);
+    }
+
     export function textSpansEqual(a: TextSpan | undefined, b: TextSpan | undefined): boolean {
         return !!a && !!b && a.start === b.start && a.length === b.length;
     }

tests/cases/fourslash/codeFixInferFromUsageContextualImport2.ts

@@ -20,7 +20,7 @@ goTo.file("/b.ts");
 verify.codeFix({
   description: "Infer parameter types from usage",
   newFileContent:
-`import type { User } from "./a";
+`import { User } from "./a";
 
 export function f(user: User) {
     getEmail(user);

tests/cases/fourslash/completionsImport_exportEquals.ts

@@ -43,7 +43,7 @@ verify.applyCodeActionFromCompletion("1", {
     source: "/a",
     description: `Import 'b' from module "./a"`,
     newFileContent:
-`import type { b } from "./a";
+`import { b } from "./a";
 
 a;
 let x: b;`,
@@ -54,7 +54,7 @@ verify.applyCodeActionFromCompletion("0", {
     source: "/a",
     description: `Import 'a' from module "./a"`,
     newFileContent:
-`import type { b } from "./a";
+`import { b } from "./a";
 import a = require("./a");
 
 a;

tests/cases/fourslash/completionsImport_typeOnly.ts

@@ -0,0 +1,24 @@
+/// <reference path="fourslash.ts" />
+
+// @target: esnext
+
+// @Filename: /a.ts
+//// export class A {}
+//// export class B {}
+
+// @Filename: /b.ts
+//// import type { A } from './a';
+//// const b: B/**/
+
+goTo.file('/b.ts');
+verify.applyCodeActionFromCompletion('', {
+  name: 'B',
+  source: '/a',
+  description: `Add 'B' to existing import declaration from "./a"`,
+  preferences: {
+    includeCompletionsForModuleExports: true,
+    includeInsertTextCompletions: true
+  },
+  newFileContent: `import type { A, B } from './a';
+const b: B`
+});

tests/cases/fourslash/importNameCodeFixConvertTypeOnly1.ts

@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: /a.ts
+//// export class A {}
+//// export class B {}
+
+// @Filename: /b.ts
+//// import type { A } from './a';
+//// new B
+
+goTo.file('/b.ts');
+verify.importFixAtPosition([`import { A, B } from './a';
+new B`]);

tests/cases/fourslash/importNameCodeFixNewImportFile3.ts

@@ -9,7 +9,7 @@
 //// }
 
 verify.importFixAtPosition([
-`import type { XXX } from "./module";
+`import { XXX } from "./module";
 
 let t: XXX.I;`
 ]);

tests/cases/fourslash/importNameCodeFixNewImportFile4.ts

@@ -10,7 +10,7 @@
 //// }
 
 verify.importFixAtPosition([
-`import type { A } from "./module";
+`import { A } from "./module";
 
 let t: A.B.I;`
 ]);

tests/cases/fourslash/importNameCodeFix_exportEquals.ts

@@ -16,9 +16,9 @@ verify.codeFixAll({
     fixId: "fixMissingImport",
     fixAllDescription: "Add all missing imports",
     newFileContent:
-`import a = require("./a");
+`import { b } from "./a";
 
-import type { b } from "./a";
+import a = require("./a");
 
 a;
 let x: b;`,