Angular Webpack Compiler transformer cleanup

packages/ngtools/webpack/src/transformers/elide_imports_spec.ts

@@ -8,23 +8,50 @@
 // tslint:disable:no-big-function
 import { tags } from '@angular-devkit/core';  // tslint:disable-line:no-implicit-dependencies
 import * as ts from 'typescript';
-import { getLastNode } from './ast_helpers';
-import { RemoveNodeOperation } from './interfaces';
-import { makeTransform } from './make_transform';
+import { elideImports } from './elide_imports';
 import { createTypescriptContext, transformTypescript } from './spec_helpers';
 
 describe('@ngtools/webpack transformers', () => {
   describe('elide_imports', () => {
 
     const dummyNode = `const remove = ''`;
 
-    const transformer = (program: ts.Program) => (
-      makeTransform(
-        (sourceFile: ts.SourceFile) =>
-          [new RemoveNodeOperation(sourceFile, getLastNode(sourceFile) as ts.Node)],
-        () => program.getTypeChecker(),
-      )
-    );
+    // Transformer that removes the last node and then elides unused imports
+    const transformer = (program: ts.Program) => {
+      return (context: ts.TransformationContext) => {
+
+        return (sourceFile: ts.SourceFile) => {
+          const lastNode = sourceFile.statements[sourceFile.statements.length - 1];
+          const updatedSourceFile = context.factory.updateSourceFile(
+            sourceFile,
+            ts.setTextRange(
+              context.factory.createNodeArray(sourceFile.statements.slice(0, -1)),
+              sourceFile.statements,
+            ),
+          );
+
+          const importRemovals = elideImports(
+            updatedSourceFile,
+            [lastNode],
+            () => program.getTypeChecker(),
+            context.getCompilerOptions(),
+          ).map((op) => op.target);
+          if (importRemovals.length > 0) {
+            return ts.visitEachChild(
+              updatedSourceFile,
+              function visitForRemoval(node): ts.Node | undefined {
+                return importRemovals.includes(node)
+                  ? undefined
+                  : ts.visitEachChild(node, visitForRemoval, context);
+              },
+              context,
+            );
+          }
+
+          return updatedSourceFile;
+        };
+      };
+    };
 
     const additionalFiles: Record<string, string> = {
       'const.ts': `

packages/ngtools/webpack/src/transformers/index.ts

@@ -5,8 +5,5 @@
  * 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
  */
-export * from './interfaces';
-export * from './ast_helpers';
-export * from './make_transform';
 export * from './elide_imports';
 export * from './replace_resources';

packages/ngtools/webpack/src/transformers/remove-ivy-jit-support-calls.ts

@@ -6,56 +6,71 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as ts from 'typescript';
-import { collectDeepNodes } from './ast_helpers';
-import { RemoveNodeOperation, StandardTransform, TransformOperation } from './interfaces';
-import { makeTransform } from './make_transform';
+import { elideImports } from './elide_imports';
 
 export function removeIvyJitSupportCalls(
   classMetadata: boolean,
   ngModuleScope: boolean,
   getTypeChecker: () => ts.TypeChecker,
 ): ts.TransformerFactory<ts.SourceFile> {
-  const standardTransform: StandardTransform = function(sourceFile: ts.SourceFile) {
-    const ops: TransformOperation[] = [];
-
-    collectDeepNodes<ts.ExpressionStatement>(sourceFile, ts.SyntaxKind.ExpressionStatement)
-      .filter(statement => {
-        const innerStatement = getIifeStatement(statement);
-        if (!innerStatement) {
-          return false;
+  return (context: ts.TransformationContext) => {
+    const removedNodes: ts.Node[] = [];
+
+    const visitNode: ts.Visitor = (node: ts.Node) => {
+      const innerStatement = ts.isExpressionStatement(node) && getIifeStatement(node);
+      if (innerStatement) {
+        if (
+          ngModuleScope &&
+          ts.isBinaryExpression(innerStatement.expression) &&
+          isIvyPrivateCallExpression(innerStatement.expression.right, 'ɵɵsetNgModuleScope')
+        ) {
+          removedNodes.push(innerStatement);
+
+          return undefined;
         }
 
-        let shouldRemove = false;
+        if (classMetadata) {
+          const expression = ts.isBinaryExpression(innerStatement.expression)
+            ? innerStatement.expression.right
+            : innerStatement.expression;
+          if (isIvyPrivateCallExpression(expression, 'ɵsetClassMetadata')) {
+            removedNodes.push(innerStatement);
 
-        if (ngModuleScope && ts.isBinaryExpression(innerStatement.expression)) {
-          shouldRemove = isIvyPrivateCallExpression(
-            innerStatement.expression.right,
-            'ɵɵsetNgModuleScope',
-          );
-        }
-
-        if (classMetadata && !shouldRemove) {
-          if (ts.isBinaryExpression(innerStatement.expression)) {
-            shouldRemove = isIvyPrivateCallExpression(
-              innerStatement.expression.right,
-              'ɵsetClassMetadata',
-            );
-          } else {
-            shouldRemove = isIvyPrivateCallExpression(
-              innerStatement.expression,
-              'ɵsetClassMetadata',
-            );
+            return undefined;
           }
         }
+      }
+
+      return ts.visitEachChild(node, visitNode, context);
+    };
+
+    return (sourceFile: ts.SourceFile) => {
+      let updatedSourceFile = ts.visitEachChild(sourceFile, visitNode, context);
+
+      if (removedNodes.length > 0) {
+        // Remove any unused imports
+        const importRemovals = elideImports(
+          updatedSourceFile,
+          removedNodes,
+          getTypeChecker,
+          context.getCompilerOptions(),
+        ).map((op) => op.target);
+        if (importRemovals.length > 0) {
+          updatedSourceFile = ts.visitEachChild(
+            updatedSourceFile,
+            function visitForRemoval(node): ts.Node | undefined {
+              return importRemovals.includes(node)
+                ? undefined
+                : ts.visitEachChild(node, visitForRemoval, context);
+            },
+            context,
+          );
+        }
+      }
 
-        return shouldRemove;
-      })
-      .forEach(statement => ops.push(new RemoveNodeOperation(sourceFile, statement)));
-
-    return ops;
+      return updatedSourceFile;
+    };
   };
-
-  return makeTransform(standardTransform, getTypeChecker);
 }
 
 // Each Ivy private call expression is inside an IIFE