feat(@ngtools/webpack): support default/namespace import eliding

Author: clydin

packages/@ngtools/webpack/src/transformers/elide_imports.ts

@@ -1,19 +1,7 @@
-// @ignoreDep typescript
 import * as ts from 'typescript';
-
-import { collectDeepNodes } from './ast_helpers';
 import { RemoveNodeOperation, TransformOperation } from './interfaces';
 
 
-interface RemovedSymbol {
-  symbol: ts.Symbol;
-  importDecl: ts.ImportDeclaration;
-  importSpec: ts.ImportSpecifier;
-  singleImport: boolean;
-  removed: ts.Identifier[];
-  all: ts.Identifier[];
-}
-
 // 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.
@@ -31,95 +19,82 @@ export function elideImports(
     return [];
   }
 
-  // Get all children identifiers inside the removed nodes.
-  const removedIdentifiers = removedNodes
-    .map((node) => collectDeepNodes<ts.Identifier>(node, ts.SyntaxKind.Identifier))
-    .reduce((prev, curr) => prev.concat(curr), [])
-    // Also add the top level nodes themselves if they are identifiers.
-    .concat(removedNodes.filter((node) =>
-      node.kind === ts.SyntaxKind.Identifier) as ts.Identifier[]);
+  const typeChecker = getTypeChecker();
 
-  if (removedIdentifiers.length === 0) {
+  // Collect all imports and used identifiers
+  const exportSpecifiers = new Set<string>();
+  const usedSymbols = new Set<ts.Symbol>();
+  const imports = new Array<ts.ImportDeclaration>();
+  ts.forEachChild(sourceFile, function visit(node) {
+    // Skip removed nodes
+    if (removedNodes.includes(node)) {
+      return;
+    }
+
+    // Record import and skip
+    if (ts.isImportDeclaration(node)) {
+      imports.push(node);
+      return;
+    }
+
+    if (ts.isIdentifier(node)) {
+      usedSymbols.add(typeChecker.getSymbolAtLocation(node));
+    } else if (ts.isExportSpecifier(node)) {
+      // Export specifiers return the non-local symbol from the above
+      // so check the name string instead
+      exportSpecifiers.add((node.propertyName || node.name).text);
+      return;
+    }
+
+    ts.forEachChild(node, visit);
+  });
+
+  if (imports.length === 0) {
     return [];
   }
 
-  // Get all imports in the source file.
-  const allImports = collectDeepNodes<ts.ImportDeclaration>(
-    sourceFile, ts.SyntaxKind.ImportDeclaration);
+  const isUnused = (node: ts.Identifier) => {
+    if (exportSpecifiers.has(node.text)) {
+      return false;
+    }
 
-  if (allImports.length === 0) {
-    return [];
-  }
+    const symbol = typeChecker.getSymbolAtLocation(node);
 
-  const removedSymbolMap: Map<string, RemovedSymbol> = new Map();
-  const typeChecker = getTypeChecker();
+    return symbol && !usedSymbols.has(symbol);
+  };
+
+  for (const node of imports) {
+    if (!node.importClause) {
+      // "import 'abc';"
+      continue;
+    }
 
-  // Find all imports that use a removed identifier and add them to the map.
-  allImports
-    .filter((node: ts.ImportDeclaration) => {
-      // TODO: try to support removing `import * as X from 'XYZ'`.
-      // Filter out import statements that are either `import 'XYZ'` or `import * as X from 'XYZ'`.
-      const clause = node.importClause as ts.ImportClause;
-      if (!clause || clause.name || !clause.namedBindings) {
-        return false;
+    if (node.importClause.name) {
+      // "import XYZ from 'abc';"
+      if (isUnused(node.importClause.name)) {
+        ops.push(new RemoveNodeOperation(sourceFile, node));
       }
-      return clause.namedBindings.kind == ts.SyntaxKind.NamedImports;
-    })
-    .forEach((importDecl: ts.ImportDeclaration) => {
-      const importClause = importDecl.importClause as ts.ImportClause;
-      const namedImports = importClause.namedBindings as ts.NamedImports;
-
-      namedImports.elements.forEach((importSpec: ts.ImportSpecifier) => {
-        const importId = importSpec.name;
-        const symbol = typeChecker.getSymbolAtLocation(importId);
-
-        const removedNodesForImportId = removedIdentifiers.filter((id) =>
-          id.text === importId.text && typeChecker.getSymbolAtLocation(id) === symbol);
-
-        if (removedNodesForImportId.length > 0) {
-          removedSymbolMap.set(importId.text, {
-            symbol,
-            importDecl,
-            importSpec,
-            singleImport: namedImports.elements.length === 1,
-            removed: removedNodesForImportId,
-            all: []
-          });
+    } else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+      // "import * as XYZ from 'abc';"
+      if (isUnused(node.importClause.namedBindings.name)) {
+        ops.push(new RemoveNodeOperation(sourceFile, node));
+      }
+    } else if (ts.isNamedImports(node.importClause.namedBindings)) {
+      // "import { XYZ, ... } from 'abc';"
+      const specifierOps = [];
+      for (const specifier of node.importClause.namedBindings.elements) {
+        if (isUnused(specifier.propertyName || specifier.name)) {
+          specifierOps.push(new RemoveNodeOperation(sourceFile, specifier));
         }
-      });
-    });
-
-
-  if (removedSymbolMap.size === 0) {
-    return [];
-  }
+      }
 
-  // Find all identifiers in the source file that have a removed symbol, and add them to the map.
-  collectDeepNodes<ts.Identifier>(sourceFile, ts.SyntaxKind.Identifier)
-    .forEach((id) => {
-      if (removedSymbolMap.has(id.text)) {
-        const symbol = removedSymbolMap.get(id.text);
-
-        // Check if the symbol is the same or if it is a named export.
-        // Named exports don't have the same symbol but will have the same name.
-        if ((id.parent && id.parent.kind === ts.SyntaxKind.ExportSpecifier)
-          || typeChecker.getSymbolAtLocation(id) === symbol.symbol) {
-          symbol.all.push(id);
-        }
+      if (specifierOps.length === node.importClause.namedBindings.elements.length) {
+        ops.push(new RemoveNodeOperation(sourceFile, node));
+      } else {
+        ops.push(...specifierOps);
       }
-    });
-
-  Array.from(removedSymbolMap.values())
-    .filter((symbol) => {
-      // If the number of removed imports plus one (the import specifier) is equal to the total
-      // number of identifiers for that symbol, it's safe to remove the import.
-      return symbol.removed.length + 1 === symbol.all.length;
-    })
-    .forEach((symbol) => {
-      // Remove the whole declaration if it's a single import.
-      const nodeToRemove = symbol.singleImport ? symbol.importDecl : symbol.importSpec;
-      ops.push(new RemoveNodeOperation(sourceFile, nodeToRemove));
-    });
+    }
+  }
 
   return ops;
 }