fix(@schematics/angular): avoid tslint overhead for lazy module migration

By using a pure schematic based implementation the overhead of running tslint can be removed.  This also has the benefit of allowing direct control over the files loaded and to modify files only within the schematic tree context.
For a hello world application, there was a ~20% performance improvement for the CLI migration from 7.0 to 8.0 as well as a ~10% reduction in memory usage.

Author: clydin

packages/schematics/angular/migrations/update-8/rules/noLazyModulePathsRule.ts

@@ -5,26 +5,72 @@
  * 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 {
-  Rule,
-  SchematicContext,
-  Tree,
-} from '@angular-devkit/schematics';
-import {
-  TslintFixTask,
-} from '@angular-devkit/schematics/tasks';
-import * as path from 'path';
-
-export const updateLazyModulePaths = (): Rule => {
-  return (_: Tree, context: SchematicContext) => {
-    context.addTask(new TslintFixTask({
-      rulesDirectory: path.join(__dirname, 'rules'),
-      rules: {
-        'no-lazy-module-paths': [true],
-      },
-    }, {
-      includes: '**/*.ts',
-      silent: false,
-    }));
+import { DirEntry, Rule, UpdateRecorder } from '@angular-devkit/schematics';
+import * as ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+
+function* visit(directory: DirEntry): IterableIterator<ts.SourceFile> {
+  for (const path of directory.subfiles) {
+    if (path.endsWith('.ts') && !path.endsWith('.d.ts')) {
+      const entry = directory.file(path);
+      if (entry) {
+        const content = entry.content;
+        if (content.includes('loadChildren')) {
+          const source = ts.createSourceFile(
+            entry.path,
+            content.toString(),
+            ts.ScriptTarget.Latest,
+            true,
+          );
+
+          yield source;
+        }
+      }
+    }
+  }
+
+  for (const path of directory.subdirs) {
+    if (path === 'node_modules') {
+      continue;
+    }
+
+    yield* visit(directory.dir(path));
+  }
+}
+
+export function updateLazyModulePaths(): Rule {
+  return tree => {
+    for (const sourceFile of visit(tree.root)) {
+      let recorder: UpdateRecorder | undefined;
+
+      ts.forEachChild(sourceFile, function analyze(node) {
+        if (ts.isPropertyAssignment(node) &&
+            (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name)) &&
+            node.name.text === 'loadChildren' &&
+            ts.isStringLiteral(node.initializer)) {
+          const valueNode = node.initializer;
+          const parts = valueNode.text.split('#');
+          const path = parts[0];
+          const moduleName = parts[1] || 'default';
+
+          const fix = `() => import('${path}').then(m => m.${moduleName})`;
+
+          if (!recorder) {
+            recorder = tree.beginUpdate(sourceFile.fileName);
+          }
+
+          const index = valueNode.getStart();
+          const length = valueNode.getWidth();
+          recorder
+            .remove(index, length)
+            .insertLeft(index, fix);
+        }
+
+        ts.forEachChild(node, analyze);
+      });
+
+      if (recorder) {
+        tree.commitUpdate(recorder);
+      }
+    }
   };
-};
+}

packages/schematics/angular/migrations/update-8/update-lazy-module-paths.ts

@@ -5,9 +5,8 @@
  * 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 { getSystemPath, normalize, virtualFs } from '@angular-devkit/core';
-import { TempScopedNodeJsSyncHost } from '@angular-devkit/core/node/testing';
-import { HostTree } from '@angular-devkit/schematics';
+import { normalize, virtualFs } from '@angular-devkit/core';
+import { EmptyTree } from '@angular-devkit/schematics';
 import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
 
 describe('Migration to version 8', () => {
@@ -17,7 +16,6 @@ describe('Migration to version 8', () => {
   );
 
   let tree: UnitTestTree;
-  let host: TempScopedNodeJsSyncHost;
 
   const lazyRoutePath = normalize('src/lazy-route.ts');
   const lazyRoute = virtualFs.stringToFileBuffer(`
@@ -45,36 +43,30 @@ describe('Migration to version 8', () => {
 
   describe('Migration to import() style lazy routes', () => {
     beforeEach(async () => {
-      host = new TempScopedNodeJsSyncHost();
-      tree = new UnitTestTree(new HostTree(host));
+      tree = new UnitTestTree(new EmptyTree());
       tree.create('/package.json', JSON.stringify({}));
-      process.chdir(getSystemPath(host.root));
     });
 
     it('should replace the module path string', async () => {
-      await host.write(lazyRoutePath, lazyRoute).toPromise();
+      tree.create(lazyRoutePath, Buffer.from(lazyRoute));
 
       schematicRunner.runSchematic('migration-08', {}, tree);
       await schematicRunner.engine.executePostTasks().toPromise();
 
-      const routes = await host.read(lazyRoutePath)
-        .toPromise()
-        .then(virtualFs.fileBufferToString);
+      const routes = tree.readContent(lazyRoutePath);
 
       expect(routes).not.toContain('./lazy/lazy.module#LazyModule');
       expect(routes).toContain(
         `loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule)`);
     });
 
     it('should replace the module path string in a child path', async () => {
-      await host.write(lazyRoutePath, lazyChildRoute).toPromise();
+      tree.create(lazyRoutePath, Buffer.from(lazyChildRoute));
 
       schematicRunner.runSchematic('migration-08', {}, tree);
       await schematicRunner.engine.executePostTasks().toPromise();
 
-      const routes = await host.read(lazyRoutePath)
-        .toPromise()
-        .then(virtualFs.fileBufferToString);
+      const routes = tree.readContent(lazyRoutePath);
 
       expect(routes).not.toContain('./lazy/lazy.module#LazyModule');