feat(ivy): implement listing lazy routes for specific entry point in ngtsc

Related: angular/angular-cli#13532

Jira issue: FW-860

Author: gkalpak

packages/compiler-cli/src/ngtsc/program.ts

@@ -191,12 +191,8 @@ export class NgtscProgram implements api.Program {
   }
 
   listLazyRoutes(entryRoute?: string|undefined): api.LazyRoute[] {
-    if (entryRoute !== undefined) {
-      throw new Error(
-          `Listing specific routes is unsupported for now (got query for ${entryRoute})`);
-    }
     this.ensureAnalyzed();
-    return this.routeAnalyzer !.listLazyRoutes();
+    return this.routeAnalyzer !.listLazyRoutes(entryRoute);
   }
 
   getLibrarySummaries(): Map<string, api.LibrarySummary> {

packages/compiler-cli/src/ngtsc/routing/src/analyzer.ts

@@ -11,7 +11,7 @@ import * as ts from 'typescript';
 import {ModuleResolver} from '../../imports';
 import {PartialEvaluator} from '../../partial_evaluator';
 
-import {scanForRouteEntryPoints} from './lazy';
+import {scanForCandidateTransitiveModules, scanForRouteEntryPoints} from './lazy';
 import {RouterEntryPointManager} from './route';
 
 export interface NgModuleRawRouteData {
@@ -48,18 +48,55 @@ export class NgModuleRouteAnalyzer {
              });
   }
 
-  listLazyRoutes(): LazyRoute[] {
+  listLazyRoutes(entryModuleKey?: string|undefined): LazyRoute[] {
+    if ((entryModuleKey !== undefined) && !this.modules.has(entryModuleKey)) {
+      throw new Error(`Failed to list lazy routes: Unknown module '${entryModuleKey}'.`);
+    }
+
     const routes: LazyRoute[] = [];
-    for (const key of Array.from(this.modules.keys())) {
+    const scannedModuleKeys = new Set<string>();
+    const pendingModuleKeys = entryModuleKey ? [entryModuleKey] : Array.from(this.modules.keys());
+
+    // When listing lazy routes for a specific entry module, we need to recursively extract
+    // "transitive" routes from imported/exported modules. This is not necessary when listing all
+    // lazy routes, because all analyzed modules will be scanned anyway.
+    const scanRecursively = entryModuleKey !== undefined;
+
+    while (pendingModuleKeys.length > 0) {
+      const key = pendingModuleKeys.pop() !;
+
+      if (scannedModuleKeys.has(key)) {
+        continue;
+      } else {
+        scannedModuleKeys.add(key);
+      }
+
       const data = this.modules.get(key) !;
       const entryPoints = scanForRouteEntryPoints(
           data.sourceFile, data.moduleName, data, this.entryPointManager, this.evaluator);
+
       routes.push(...entryPoints.map(entryPoint => ({
                                        route: entryPoint.loadChildren,
                                        module: entryPoint.from,
                                        referencedModule: entryPoint.resolvedTo,
                                      })));
+
+      if (scanRecursively) {
+        pendingModuleKeys.push(...[
+                                   // Scan the retrieved lazy route entry points.
+                                   ...entryPoints.map(
+                                       ({resolvedTo}) => this.entryPointManager.keyFor(
+                                           resolvedTo.filePath, resolvedTo.moduleName)),
+                                   // Scan the current module's imported modules.
+                                   ...scanForCandidateTransitiveModules(
+                                       data.imports, this.entryPointManager, this.evaluator),
+                                   // Scan the current module's exported modules.
+                                   ...scanForCandidateTransitiveModules(
+                                       data.exports, this.entryPointManager, this.evaluator),
+        ].filter(key => this.modules.has(key)));
+      }
     }
+
     return routes;
   }
 }

packages/compiler-cli/src/ngtsc/routing/src/lazy.ts

@@ -22,6 +22,36 @@ export interface LazyRouteEntry {
   resolvedTo: RouterEntryPoint;
 }
 
+export function scanForCandidateTransitiveModules(
+    expr: ts.Expression | null, entryPointManager: RouterEntryPointManager,
+    evaluator: PartialEvaluator): string[] {
+  if (expr === null) {
+    return [];
+  }
+
+  const candidateModuleKeys: string[] = [];
+  const entries = evaluator.evaluate(expr);
+
+  function recursivelyAddModules(entry: ResolvedValue) {
+    if (Array.isArray(entry)) {
+      for (const e of entry) {
+        recursivelyAddModules(e);
+      }
+    } else if (entry instanceof Map) {
+      if (entry.has('ngModule')) {
+        recursivelyAddModules(entry.get('ngModule') !);
+      }
+    } else if ((entry instanceof Reference) && hasIdentifier(entry.node)) {
+      const filePath = entry.node.getSourceFile().fileName;
+      const moduleName = entry.node.name.text;
+      candidateModuleKeys.push(entryPointManager.keyFor(filePath, moduleName));
+    }
+  }
+
+  recursivelyAddModules(entries);
+  return candidateModuleKeys;
+}
+
 export function scanForRouteEntryPoints(
     ngModule: ts.SourceFile, moduleName: string, data: NgModuleRawRouteData,
     entryPointManager: RouterEntryPointManager, evaluator: PartialEvaluator): LazyRouteEntry[] {
@@ -152,6 +182,11 @@ const routerModuleFFR: ForeignFunctionResolver =
       ]);
     };
 
+function hasIdentifier(node: ts.Node): node is ts.Node&{name: ts.Identifier} {
+  const node_ = node as ts.NamedDeclaration;
+  return (node_.name !== undefined) && ts.isIdentifier(node_.name);
+}
+
 function isMethodNodeReference(
     ref: Reference<ts.FunctionDeclaration|ts.MethodDeclaration|ts.FunctionExpression>):
     ref is NodeReference<ts.MethodDeclaration> {

packages/compiler-cli/test/BUILD.bazel

@@ -106,7 +106,6 @@ ts_library(
         ":test_utils",
         "//packages/compiler",
         "//packages/compiler-cli",
-        "//packages/private/testing",
         "@ngdeps//typescript",
     ],
 )

packages/compiler-cli/test/ngtools_api_spec.ts

@@ -7,7 +7,6 @@
  */
 
 import {__NGTOOLS_PRIVATE_API_2 as NgTools_InternalApi_NG_2} from '@angular/compiler-cli';
-import {fixmeIvy} from '@angular/private/testing';
 import * as path from 'path';
 import * as ts from 'typescript';
 
@@ -60,7 +59,7 @@ describe('ngtools_api (deprecated)', () => {
     });
   }
 
-  fixmeIvy('FW-629: ngtsc lists lazy routes').it('should list lazy routes recursively', () => {
+  fit('should list lazy routes recursively', () => {
     writeSomeRoutes();
     const {program, host, options} = createProgram(['src/main.ts']);
     const routes = NgTools_InternalApi_NG_2.listLazyRoutes({