Skip to content

Process type nodes in codefixes/refactors for auto-imports recursively #39130

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 7, 2020
Merged

Process type nodes in codefixes/refactors for auto-imports recursively #39130

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
55f863a
Process type nodes for auto-imports recursively
andrewbranch Jun 18, 2020
b34f95f
Rename function
andrewbranch Jun 18, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 38 additions & 46 deletions src/services/codefixes/helpers.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -52,9 +52,9 @@ namespace ts.codefix {
const flags = preferences.quotePreference === "single" ? NodeBuilderFlags.UseSingleQuotesForStringLiteralType : undefined;
let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
if (importAdder) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
if (importableReference) {
typeNode = importableReference.typeReference;
typeNode = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
}
Expand All @@ -74,9 +74,9 @@ namespace ts.codefix {
? [allAccessors.firstAccessor, allAccessors.secondAccessor]
: [allAccessors.firstAccessor];
if (importAdder) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
if (importableReference) {
typeNode = importableReference.typeReference;
typeNode = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
}
Expand Down Expand Up @@ -172,21 +172,20 @@ namespace ts.codefix {
let type = signatureDeclaration.type;
if (importAdder) {
if (typeParameters) {
const newTypeParameters = sameMap(typeParameters, (typeParameterDecl, i) => {
const typeParameter = signature.typeParameters![i];
const newTypeParameters = sameMap(typeParameters, typeParameterDecl => {
let constraint = typeParameterDecl.constraint;
let defaultType = typeParameterDecl.default;
if (constraint) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(constraint, typeParameter.constraint, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(constraint, scriptTarget);
if (importableReference) {
constraint = importableReference.typeReference;
constraint = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
}
if (defaultType) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(defaultType, typeParameter.default, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(defaultType, scriptTarget);
if (importableReference) {
defaultType = importableReference.typeReference;
defaultType = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
}
Expand All @@ -201,12 +200,11 @@ namespace ts.codefix {
typeParameters = setTextRange(factory.createNodeArray(newTypeParameters, typeParameters.hasTrailingComma), typeParameters);
}
}
const newParameters = sameMap(parameters, (parameterDecl, i) => {
const parameter = signature.parameters[i];
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(parameterDecl.type, checker.getTypeAtLocation(parameter.valueDeclaration), scriptTarget);
const newParameters = sameMap(parameters, parameterDecl => {
const importableReference = tryGetAutoImportableReferenceFromTypeNode(parameterDecl.type, scriptTarget);
let type = parameterDecl.type;
if (importableReference) {
type = importableReference.typeReference;
type = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
return factory.updateParameterDeclaration(
Expand All @@ -224,9 +222,9 @@ namespace ts.codefix {
parameters = setTextRange(factory.createNodeArray(newParameters, parameters.hasTrailingComma), parameters);
}
if (type) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(type, signature.resolvedReturnType, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(type, scriptTarget);
if (importableReference) {
type = importableReference.typeReference;
type = importableReference.typeNode;
importSymbols(importAdder, importableReference.symbols);
}
}
Expand Down Expand Up @@ -282,10 +280,10 @@ namespace ts.codefix {
export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder: ImportAdder, type: Type, contextNode: Node, scriptTarget: ScriptTarget, flags?: NodeBuilderFlags, tracker?: SymbolTracker): TypeNode | undefined {
const typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
if (typeNode && isImportTypeNode(typeNode)) {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
if (importableReference) {
importSymbols(importAdder, importableReference.symbols);
return importableReference.typeReference;
return importableReference.typeNode;
}
}
return typeNode;
Expand Down Expand Up @@ -450,38 +448,32 @@ namespace ts.codefix {
}

/**
* Given an ImportTypeNode 'import("./a").SomeType<import("./b").OtherType<...>>',
* Given a type node containing 'import("./a").SomeType<import("./b").OtherType<...>>',
* returns an equivalent type reference node with any nested ImportTypeNodes also replaced
* with type references, and a list of symbols that must be imported to use the type reference.
*/
export function tryGetAutoImportableReferenceFromImportTypeNode(importTypeNode: TypeNode | undefined, type: Type | undefined, scriptTarget: ScriptTarget) {
if (importTypeNode && isLiteralImportTypeNode(importTypeNode) && importTypeNode.qualifier && (!type || type.symbol)) {
// Symbol for the left-most thing after the dot
const firstIdentifier = getFirstIdentifier(importTypeNode.qualifier);
const name = getNameForExportedSymbol(firstIdentifier.symbol, scriptTarget);
const qualifier = name !== firstIdentifier.text
? replaceFirstIdentifierOfEntityName(importTypeNode.qualifier, factory.createIdentifier(name))
: importTypeNode.qualifier;

const symbols = [firstIdentifier.symbol];
const typeArguments: TypeNode[] = [];
if (importTypeNode.typeArguments) {
importTypeNode.typeArguments.forEach(arg => {
const ref = tryGetAutoImportableReferenceFromImportTypeNode(arg, /*undefined*/ type, scriptTarget);
if (ref) {
symbols.push(...ref.symbols);
typeArguments.push(ref.typeReference);
}
else {
typeArguments.push(arg);
}
});
}
export function tryGetAutoImportableReferenceFromTypeNode(importTypeNode: TypeNode | undefined, scriptTarget: ScriptTarget) {
let symbols: Symbol[] | undefined;
const typeNode = visitNode(importTypeNode, visit);
if (symbols && typeNode) {
return { typeNode, symbols };
}

return {
symbols,
typeReference: factory.createTypeReferenceNode(qualifier, typeArguments)
};
function visit(node: TypeNode): TypeNode;
function visit(node: Node): Node {
if (isLiteralImportTypeNode(node) && node.qualifier) {
// Symbol for the left-most thing after the dot
const firstIdentifier = getFirstIdentifier(node.qualifier);
const name = getNameForExportedSymbol(firstIdentifier.symbol, scriptTarget);
const qualifier = name !== firstIdentifier.text
? replaceFirstIdentifierOfEntityName(node.qualifier, factory.createIdentifier(name))
: node.qualifier;

symbols = append(symbols, firstIdentifier.symbol);
const typeArguments = node.typeArguments?.map(visit);
return factory.createTypeReferenceNode(qualifier, typeArguments);
}
return visitEachChild(node, visit, nullTransformationContext);
}
}

Expand Down
7 changes: 3 additions & 4 deletions src/services/codefixes/inferFromUsage.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -310,7 +310,7 @@ namespace ts.codefix {
const typeTag = isGetAccessorDeclaration(declaration) ? factory.createJSDocReturnTag(/*tagName*/ undefined, typeExpression, "") : factory.createJSDocTypeTag(/*tagName*/ undefined, typeExpression, "");
addJSDocTags(changes, sourceFile, parent, [typeTag]);
}
else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, type, sourceFile, changes, importAdder, getEmitScriptTarget(program.getCompilerOptions()))) {
else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, getEmitScriptTarget(program.getCompilerOptions()))) {
changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode);
}
}
Expand All @@ -319,14 +319,13 @@ namespace ts.codefix {
function tryReplaceImportTypeNodeWithAutoImport(
typeNode: TypeNode,
declaration: textChanges.TypeAnnotatable,
type: Type,
sourceFile: SourceFile,
changes: textChanges.ChangeTracker,
importAdder: ImportAdder,
scriptTarget: ScriptTarget
): boolean {
const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeReference)) {
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeNode)) {
forEach(importableReference.symbols, s => importAdder.addImportFromExportedSymbol(s, /*usageIsTypeOnly*/ true));
return true;
}
Expand Down
4 changes: 2 additions & 2 deletions tests/cases/fourslash/codeFixClassImplementInterfaceAutoImports.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@
////import { B, C, D } from './types2';
////
////export interface Base {
//// a: A;
//// a: Readonly<A> & { kind: "a"; };
//// b<T extends B = B>(p1: C): D<C>;
////}

Expand All @@ -32,7 +32,7 @@ import A from './types1';
import { B, C, D } from './types2';

export class C implements Base {
a: A;
a: Readonly<A> & { kind: "a"; };
b<T extends B = B>(p1: C): D<C> {
throw new Error("Method not implemented.");
}
Expand Down