/
elide_imports.ts
159 lines (132 loc) · 4.7 KB
/
elide_imports.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import * as ts from 'typescript';
// Remove imports for which all identifiers have been removed.
// Needs type checker, and works even if it's not the first transformer.
// Works by removing imports for symbols whose identifiers have all been removed.
// Doesn't use the `symbol.declarations` because that previous transforms might have removed nodes
// but the type checker doesn't know.
// See https://github.com/Microsoft/TypeScript/issues/17552 for more information.
export function elideImports(
sourceFile: ts.SourceFile,
removedNodes: ts.Node[],
getTypeChecker: () => ts.TypeChecker,
compilerOptions: ts.CompilerOptions,
): Set<ts.Node> {
const importNodeRemovals = new Set<ts.Node>();
if (removedNodes.length === 0) {
return importNodeRemovals;
}
const typeChecker = getTypeChecker();
// Collect all imports and used identifiers
const usedSymbols = new Set<ts.Symbol>();
const imports: ts.ImportDeclaration[] = [];
ts.forEachChild(sourceFile, function visit(node) {
// Skip removed nodes.
if (removedNodes.includes(node)) {
return;
}
// Consider types for 'implements' as unused.
// A HeritageClause token can also be an 'AbstractKeyword'
// which in that case we should not elide the import.
if (ts.isHeritageClause(node) && node.token === ts.SyntaxKind.ImplementsKeyword) {
return;
}
// Record import and skip
if (ts.isImportDeclaration(node)) {
if (!node.importClause?.isTypeOnly) {
imports.push(node);
}
return;
}
// Type reference imports do not need to be emitted when emitDecoratorMetadata is disabled.
if (ts.isTypeReferenceNode(node) && !compilerOptions.emitDecoratorMetadata) {
return;
}
let symbol: ts.Symbol | undefined;
switch (node.kind) {
case ts.SyntaxKind.Identifier:
const parent = node.parent;
if (parent && ts.isShorthandPropertyAssignment(parent)) {
const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(parent);
if (shorthandSymbol) {
symbol = shorthandSymbol;
}
} else {
symbol = typeChecker.getSymbolAtLocation(node);
}
break;
case ts.SyntaxKind.ExportSpecifier:
symbol = typeChecker.getExportSpecifierLocalTargetSymbol(node as ts.ExportSpecifier);
break;
case ts.SyntaxKind.ShorthandPropertyAssignment:
symbol = typeChecker.getShorthandAssignmentValueSymbol(node);
break;
}
if (symbol) {
usedSymbols.add(symbol);
}
ts.forEachChild(node, visit);
});
if (imports.length === 0) {
return importNodeRemovals;
}
const isUnused = (node: ts.Identifier) => {
// Do not remove JSX factory imports
if (node.text === compilerOptions.jsxFactory) {
return false;
}
const symbol = typeChecker.getSymbolAtLocation(node);
return symbol && !usedSymbols.has(symbol);
};
for (const node of imports) {
if (!node.importClause) {
// "import 'abc';"
continue;
}
const namedBindings = node.importClause.namedBindings;
if (namedBindings && ts.isNamespaceImport(namedBindings)) {
// "import * as XYZ from 'abc';"
if (isUnused(namedBindings.name)) {
importNodeRemovals.add(node);
}
} else {
const specifierNodeRemovals = [];
let clausesCount = 0;
// "import { XYZ, ... } from 'abc';"
if (namedBindings && ts.isNamedImports(namedBindings)) {
let removedClausesCount = 0;
clausesCount += namedBindings.elements.length;
for (const specifier of namedBindings.elements) {
if (specifier.isTypeOnly || isUnused(specifier.name)) {
removedClausesCount++;
// in case we don't have any more namedImports we should remove the parent ie the {}
const nodeToRemove =
clausesCount === removedClausesCount ? specifier.parent : specifier;
specifierNodeRemovals.push(nodeToRemove);
}
}
}
// "import XYZ from 'abc';"
if (node.importClause.name) {
clausesCount++;
if (node.importClause.isTypeOnly || isUnused(node.importClause.name)) {
specifierNodeRemovals.push(node.importClause.name);
}
}
if (specifierNodeRemovals.length === clausesCount) {
importNodeRemovals.add(node);
} else {
for (const specifierNodeRemoval of specifierNodeRemovals) {
importNodeRemovals.add(specifierNodeRemoval);
}
}
}
}
return importNodeRemovals;
}