@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/schematics/migrations/router-link-empty-expression/angular/html_routerlink_empty_expr_visitor.js

@@ -11,38 +11,37 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/migrations/router-link-empty-expression/angular/html_routerlink_empty_expr_visitor", ["require", "exports", "@angular/compiler", "@angular/compiler/src/render3/r3_ast"], factory);
+        define("@angular/core/schematics/migrations/router-link-empty-expression/angular/html_routerlink_empty_expr_visitor", ["require", "exports", "@angular/core/schematics/utils/template_ast_visitor"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.RouterLinkEmptyExprVisitor = void 0;
-    const compiler_1 = require("@angular/compiler");
-    const r3_ast_1 = require("@angular/compiler/src/render3/r3_ast");
+    const template_ast_visitor_1 = require("@angular/core/schematics/utils/template_ast_visitor");
     /**
      * HTML AST visitor that traverses the Render3 HTML AST in order to find all
      * undefined routerLink asssignment ([routerLink]="").
      */
-    class RouterLinkEmptyExprVisitor extends r3_ast_1.NullVisitor {
+    class RouterLinkEmptyExprVisitor extends template_ast_visitor_1.TemplateAstVisitor {
         constructor() {
             super(...arguments);
             this.emptyRouterLinkExpressions = [];
         }
         visitElement(element) {
-            (0, r3_ast_1.visitAll)(this, element.inputs);
-            (0, r3_ast_1.visitAll)(this, element.children);
+            this.visitAll(element.inputs);
+            this.visitAll(element.children);
         }
         visitTemplate(t) {
-            (0, r3_ast_1.visitAll)(this, t.inputs);
-            (0, r3_ast_1.visitAll)(this, t.children);
+            this.visitAll(t.inputs);
+            this.visitAll(t.children);
         }
         visitBoundAttribute(node) {
-            if (node.name === 'routerLink' && node.value instanceof compiler_1.ASTWithSource &&
-                node.value.ast instanceof compiler_1.EmptyExpr) {
+            if (node.name === 'routerLink' && node.value instanceof this.compilerModule.ASTWithSource &&
+                node.value.ast instanceof this.compilerModule.EmptyExpr) {
                 this.emptyRouterLinkExpressions.push(node);
             }
         }
     }
     exports.RouterLinkEmptyExprVisitor = RouterLinkEmptyExprVisitor;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/router-link-empty-expression/index.js

@@ -20,7 +20,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/migrations/router-link-empty-expression", ["require", "exports", "@angular-devkit/core", "@angular-devkit/schematics", "path", "@angular/core/schematics/utils/ng_component_template", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/router-link-empty-expression/analyze_template"], factory);
+        define("@angular/core/schematics/migrations/router-link-empty-expression", ["require", "exports", "@angular-devkit/core", "@angular-devkit/schematics", "path", "@angular/core/schematics/utils/load_esm", "@angular/core/schematics/utils/ng_component_template", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/router-link-empty-expression/analyze_template"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -28,6 +28,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const core_1 = require("@angular-devkit/core");
     const schematics_1 = require("@angular-devkit/schematics");
     const path_1 = require("path");
+    const load_esm_1 = require("@angular/core/schematics/utils/load_esm");
     const ng_component_template_1 = require("@angular/core/schematics/utils/ng_component_template");
     const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
     const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
@@ -41,8 +42,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             if (!buildPaths.length && !testPaths.length) {
                 throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot check templates for empty routerLinks.');
             }
+            let compilerModule;
+            try {
+                // Load ESM `@angular/compiler` using the TypeScript dynamic import workaround.
+                // Once TypeScript provides support for keeping the dynamic import this workaround can be
+                // changed to a direct dynamic import.
+                compilerModule = yield (0, load_esm_1.loadEsmModule)('@angular/compiler');
+            }
+            catch (e) {
+                throw new schematics_1.SchematicsException(`Unable to load the '@angular/compiler' package. Details: ${e.message}`);
+            }
             for (const tsconfigPath of [...buildPaths, ...testPaths]) {
-                runEmptyRouterLinkExpressionMigration(tree, tsconfigPath, basePath, context.logger);
+                runEmptyRouterLinkExpressionMigration(tree, tsconfigPath, basePath, context.logger, compilerModule);
             }
         });
     }
@@ -51,7 +62,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
      * Runs the routerLink migration, changing routerLink="" to routerLink="[]" and notifying developers
      * which templates received updates.
      */
-    function runEmptyRouterLinkExpressionMigration(tree, tsconfigPath, basePath, logger) {
+    function runEmptyRouterLinkExpressionMigration(tree, tsconfigPath, basePath, logger, compilerModule) {
         const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
         const typeChecker = program.getTypeChecker();
         const templateVisitor = new ng_component_template_1.NgComponentTemplateVisitor(typeChecker);
@@ -59,13 +70,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         // Analyze source files by detecting HTML templates.
         sourceFiles.forEach(sourceFile => templateVisitor.visitNode(sourceFile));
         const { resolvedTemplates } = templateVisitor;
-        fixEmptyRouterlinks(resolvedTemplates, tree, logger);
+        fixEmptyRouterlinks(resolvedTemplates, tree, logger, compilerModule);
     }
-    function fixEmptyRouterlinks(resolvedTemplates, tree, logger) {
+    function fixEmptyRouterlinks(resolvedTemplates, tree, logger, compilerModule) {
         var _a;
         const basePath = process.cwd();
         const collectedFixes = [];
-        const fixesByFile = getFixesByFile(resolvedTemplates);
+        const fixesByFile = getFixesByFile(resolvedTemplates, compilerModule);
         for (const [absFilePath, templateFixes] of fixesByFile) {
             const treeFilePath = (0, path_1.relative)((0, core_1.normalize)(basePath), (0, core_1.normalize)(absFilePath));
             const originalFileContent = (_a = tree.read(treeFilePath)) === null || _a === void 0 ? void 0 : _a.toString();
@@ -102,10 +113,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     /**
      * Returns fixes for nodes in templates which contain empty routerLink assignments, grouped by file.
      */
-    function getFixesByFile(templates) {
+    function getFixesByFile(templates, compilerModule) {
         const fixesByFile = new Map();
         for (const template of templates) {
-            const templateFix = fixEmptyRouterlinksInTemplate(template);
+            const templateFix = fixEmptyRouterlinksInTemplate(template, compilerModule);
             if (templateFix === null) {
                 continue;
             }
@@ -125,8 +136,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         return fixesByFile;
     }
-    function fixEmptyRouterlinksInTemplate(template) {
-        const emptyRouterlinkExpressions = (0, analyze_template_1.analyzeResolvedTemplate)(template);
+    function fixEmptyRouterlinksInTemplate(template, compilerModule) {
+        const emptyRouterlinkExpressions = (0, analyze_template_1.analyzeResolvedTemplate)(template, compilerModule);
         if (!emptyRouterlinkExpressions || emptyRouterlinkExpressions.length === 0) {
             return null;
         }
@@ -156,4 +167,4 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         return { originalTemplate: template, replacements, emptyRouterlinkExpressions };
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/router-link-empty-expression/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {logging, normalize} from '@angular-devkit/core';\nimport {Rule, SchematicContext, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {EmptyExpr, TmplAstBoundAttribute} from '@angular/compiler';\nimport {relative} from 'path';\n\nimport {NgComponentTemplateVisitor, ResolvedTemplate} from '../../utils/ng_component_template';\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {canMigrateFile, createMigrationProgram} from '../../utils/typescript/compiler_host';\n\nimport {analyzeResolvedTemplate} from './analyze_template';\n\ntype Logger = logging.LoggerApi;\n\nconst README_URL =\n    'https://github.com/angular/angular/blob/master/packages/core/schematics/migrations/router-link-empty-expression/README.md';\n\ninterface Replacement {\n  start: number;\n  end: number;\n  newContent: string;\n}\ninterface FixedTemplate {\n  originalTemplate: ResolvedTemplate;\n  replacements: Replacement[];\n  emptyRouterlinkExpressions: TmplAstBoundAttribute[];\n}\n\n/** Entry point for the RouterLink empty expression migration. */\nexport default function(): Rule {\n  return async (tree: Tree, context: SchematicContext) => {\n    const {buildPaths, testPaths} = await getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n\n    if (!buildPaths.length && !testPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot check templates for empty routerLinks.');\n    }\n\n    for (const tsconfigPath of [...buildPaths, ...testPaths]) {\n      runEmptyRouterLinkExpressionMigration(tree, tsconfigPath, basePath, context.logger);\n    }\n  };\n}\n\n/**\n * Runs the routerLink migration, changing routerLink=\"\" to routerLink=\"[]\" and notifying developers\n * which templates received updates.\n */\nfunction runEmptyRouterLinkExpressionMigration(\n    tree: Tree, tsconfigPath: string, basePath: string, logger: Logger) {\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath);\n  const typeChecker = program.getTypeChecker();\n  const templateVisitor = new NgComponentTemplateVisitor(typeChecker);\n  const sourceFiles =\n      program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));\n\n  // Analyze source files by detecting HTML templates.\n  sourceFiles.forEach(sourceFile => templateVisitor.visitNode(sourceFile));\n\n  const {resolvedTemplates} = templateVisitor;\n  fixEmptyRouterlinks(resolvedTemplates, tree, logger);\n}\n\nfunction fixEmptyRouterlinks(resolvedTemplates: ResolvedTemplate[], tree: Tree, logger: Logger) {\n  const basePath = process.cwd();\n  const collectedFixes: string[] = [];\n  const fixesByFile = getFixesByFile(resolvedTemplates);\n\n  for (const [absFilePath, templateFixes] of fixesByFile) {\n    const treeFilePath = relative(normalize(basePath), normalize(absFilePath));\n    const originalFileContent = tree.read(treeFilePath)?.toString();\n    if (originalFileContent === undefined) {\n      logger.error(\n          `Failed to read file containing template; cannot apply fixes for empty routerLink expressions in ${\n              treeFilePath}.`);\n      continue;\n    }\n\n    const updater = tree.beginUpdate(treeFilePath);\n    for (const templateFix of templateFixes) {\n      // Sort backwards so string replacements do not conflict\n      templateFix.replacements.sort((a, b) => b.start - a.start);\n      for (const replacement of templateFix.replacements) {\n        updater.remove(replacement.start, replacement.end - replacement.start);\n        updater.insertLeft(replacement.start, replacement.newContent);\n      }\n      const displayFilePath = normalize(relative(basePath, templateFix.originalTemplate.filePath));\n      for (const n of templateFix.emptyRouterlinkExpressions) {\n        const {line, character} =\n            templateFix.originalTemplate.getCharacterAndLineOfPosition(n.sourceSpan.start.offset);\n        collectedFixes.push(`${displayFilePath}@${line + 1}:${character + 1}`);\n      }\n      tree.commitUpdate(updater);\n    }\n  }\n\n  if (collectedFixes.length > 0) {\n    logger.info('---- RouterLink empty assignment schematic ----');\n    logger.info('The behavior of empty/`undefined` inputs for `routerLink` has changed');\n    logger.info('from linking to the current page to instead completely disable the link.');\n    logger.info(`Read more about this change here: ${README_URL}`);\n    logger.info('');\n    logger.info('The following empty `routerLink` inputs were found and fixed:');\n    collectedFixes.forEach(fix => logger.warn(`⮑   ${fix}`));\n  }\n}\n\n/**\n * Returns fixes for nodes in templates which contain empty routerLink assignments, grouped by file.\n */\nfunction getFixesByFile(templates: ResolvedTemplate[]): Map<string, FixedTemplate[]> {\n  const fixesByFile = new Map<string, FixedTemplate[]>();\n  for (const template of templates) {\n    const templateFix = fixEmptyRouterlinksInTemplate(template);\n    if (templateFix === null) {\n      continue;\n    }\n\n    const file = template.filePath;\n    if (fixesByFile.has(file)) {\n      if (template.inline) {\n        // External templates may be referenced multiple times in the project\n        // (e.g. if shared between components), but we only want to record them\n        // once. On the other hand, an inline template resides in a TS file that\n        // may contain multiple inline templates.\n        fixesByFile.get(file)!.push(templateFix);\n      }\n    } else {\n      fixesByFile.set(file, [templateFix]);\n    }\n  }\n\n  return fixesByFile;\n}\n\nfunction fixEmptyRouterlinksInTemplate(template: ResolvedTemplate): FixedTemplate|null {\n  const emptyRouterlinkExpressions = analyzeResolvedTemplate(template);\n\n  if (!emptyRouterlinkExpressions || emptyRouterlinkExpressions.length === 0) {\n    return null;\n  }\n\n  const replacements: Replacement[] = [];\n  for (const expr of emptyRouterlinkExpressions) {\n    let replacement: Replacement;\n    if (expr.valueSpan) {\n      replacement = {\n        start: template.start + expr.value.sourceSpan.start,\n        end: template.start + expr.value.sourceSpan.end,\n        newContent: '[]',\n      };\n    } else {\n      const spanLength = expr.sourceSpan.end.offset - expr.sourceSpan.start.offset;\n      // `expr.value.sourceSpan.start` is the start of the very beginning of the binding since there\n      // is no value\n      const endOfExpr = template.start + expr.value.sourceSpan.start + spanLength;\n      replacement = {\n        start: endOfExpr,\n        end: endOfExpr,\n        newContent: '=\"[]\"',\n      };\n    }\n    replacements.push(replacement);\n  }\n\n  return {originalTemplate: template, replacements, emptyRouterlinkExpressions};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/router-link-empty-expression/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {logging, normalize} from '@angular-devkit/core';\nimport {Rule, SchematicContext, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport type {TmplAstBoundAttribute} from '@angular/compiler';\nimport {relative} from 'path';\nimport {loadEsmModule} from '../../utils/load_esm';\n\nimport {NgComponentTemplateVisitor, ResolvedTemplate} from '../../utils/ng_component_template';\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {canMigrateFile, createMigrationProgram} from '../../utils/typescript/compiler_host';\n\nimport {analyzeResolvedTemplate} from './analyze_template';\n\ntype Logger = logging.LoggerApi;\n\nconst README_URL =\n    'https://github.com/angular/angular/blob/master/packages/core/schematics/migrations/router-link-empty-expression/README.md';\n\ninterface Replacement {\n  start: number;\n  end: number;\n  newContent: string;\n}\ninterface FixedTemplate {\n  originalTemplate: ResolvedTemplate;\n  replacements: Replacement[];\n  emptyRouterlinkExpressions: TmplAstBoundAttribute[];\n}\n\n/** Entry point for the RouterLink empty expression migration. */\nexport default function(): Rule {\n  return async (tree: Tree, context: SchematicContext) => {\n    const {buildPaths, testPaths} = await getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n\n    if (!buildPaths.length && !testPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot check templates for empty routerLinks.');\n    }\n\n    let compilerModule;\n    try {\n      // Load ESM `@angular/compiler` using the TypeScript dynamic import workaround.\n      // Once TypeScript provides support for keeping the dynamic import this workaround can be\n      // changed to a direct dynamic import.\n      compilerModule = await loadEsmModule<typeof import('@angular/compiler')>('@angular/compiler');\n    } catch (e) {\n      throw new SchematicsException(\n          `Unable to load the '@angular/compiler' package. Details: ${e.message}`);\n    }\n\n    for (const tsconfigPath of [...buildPaths, ...testPaths]) {\n      runEmptyRouterLinkExpressionMigration(\n          tree, tsconfigPath, basePath, context.logger, compilerModule);\n    }\n  };\n}\n\n/**\n * Runs the routerLink migration, changing routerLink=\"\" to routerLink=\"[]\" and notifying developers\n * which templates received updates.\n */\nfunction runEmptyRouterLinkExpressionMigration(\n    tree: Tree, tsconfigPath: string, basePath: string, logger: Logger,\n    compilerModule: typeof import('@angular/compiler')) {\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath);\n  const typeChecker = program.getTypeChecker();\n  const templateVisitor = new NgComponentTemplateVisitor(typeChecker);\n  const sourceFiles =\n      program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));\n\n  // Analyze source files by detecting HTML templates.\n  sourceFiles.forEach(sourceFile => templateVisitor.visitNode(sourceFile));\n\n  const {resolvedTemplates} = templateVisitor;\n  fixEmptyRouterlinks(resolvedTemplates, tree, logger, compilerModule);\n}\n\nfunction fixEmptyRouterlinks(\n    resolvedTemplates: ResolvedTemplate[], tree: Tree, logger: Logger,\n    compilerModule: typeof import('@angular/compiler')) {\n  const basePath = process.cwd();\n  const collectedFixes: string[] = [];\n  const fixesByFile = getFixesByFile(resolvedTemplates, compilerModule);\n\n  for (const [absFilePath, templateFixes] of fixesByFile) {\n    const treeFilePath = relative(normalize(basePath), normalize(absFilePath));\n    const originalFileContent = tree.read(treeFilePath)?.toString();\n    if (originalFileContent === undefined) {\n      logger.error(\n          `Failed to read file containing template; cannot apply fixes for empty routerLink expressions in ${\n              treeFilePath}.`);\n      continue;\n    }\n\n    const updater = tree.beginUpdate(treeFilePath);\n    for (const templateFix of templateFixes) {\n      // Sort backwards so string replacements do not conflict\n      templateFix.replacements.sort((a, b) => b.start - a.start);\n      for (const replacement of templateFix.replacements) {\n        updater.remove(replacement.start, replacement.end - replacement.start);\n        updater.insertLeft(replacement.start, replacement.newContent);\n      }\n      const displayFilePath = normalize(relative(basePath, templateFix.originalTemplate.filePath));\n      for (const n of templateFix.emptyRouterlinkExpressions) {\n        const {line, character} =\n            templateFix.originalTemplate.getCharacterAndLineOfPosition(n.sourceSpan.start.offset);\n        collectedFixes.push(`${displayFilePath}@${line + 1}:${character + 1}`);\n      }\n      tree.commitUpdate(updater);\n    }\n  }\n\n  if (collectedFixes.length > 0) {\n    logger.info('---- RouterLink empty assignment schematic ----');\n    logger.info('The behavior of empty/`undefined` inputs for `routerLink` has changed');\n    logger.info('from linking to the current page to instead completely disable the link.');\n    logger.info(`Read more about this change here: ${README_URL}`);\n    logger.info('');\n    logger.info('The following empty `routerLink` inputs were found and fixed:');\n    collectedFixes.forEach(fix => logger.warn(`⮑   ${fix}`));\n  }\n}\n\n/**\n * Returns fixes for nodes in templates which contain empty routerLink assignments, grouped by file.\n */\nfunction getFixesByFile(\n    templates: ResolvedTemplate[],\n    compilerModule: typeof import('@angular/compiler')): Map<string, FixedTemplate[]> {\n  const fixesByFile = new Map<string, FixedTemplate[]>();\n  for (const template of templates) {\n    const templateFix = fixEmptyRouterlinksInTemplate(template, compilerModule);\n    if (templateFix === null) {\n      continue;\n    }\n\n    const file = template.filePath;\n    if (fixesByFile.has(file)) {\n      if (template.inline) {\n        // External templates may be referenced multiple times in the project\n        // (e.g. if shared between components), but we only want to record them\n        // once. On the other hand, an inline template resides in a TS file that\n        // may contain multiple inline templates.\n        fixesByFile.get(file)!.push(templateFix);\n      }\n    } else {\n      fixesByFile.set(file, [templateFix]);\n    }\n  }\n\n  return fixesByFile;\n}\n\nfunction fixEmptyRouterlinksInTemplate(\n    template: ResolvedTemplate, compilerModule: typeof import('@angular/compiler')): FixedTemplate|\n    null {\n  const emptyRouterlinkExpressions = analyzeResolvedTemplate(template, compilerModule);\n\n  if (!emptyRouterlinkExpressions || emptyRouterlinkExpressions.length === 0) {\n    return null;\n  }\n\n  const replacements: Replacement[] = [];\n  for (const expr of emptyRouterlinkExpressions) {\n    let replacement: Replacement;\n    if (expr.valueSpan) {\n      replacement = {\n        start: template.start + expr.value.sourceSpan.start,\n        end: template.start + expr.value.sourceSpan.end,\n        newContent: '[]',\n      };\n    } else {\n      const spanLength = expr.sourceSpan.end.offset - expr.sourceSpan.start.offset;\n      // `expr.value.sourceSpan.start` is the start of the very beginning of the binding since there\n      // is no value\n      const endOfExpr = template.start + expr.value.sourceSpan.start + spanLength;\n      replacement = {\n        start: endOfExpr,\n        end: endOfExpr,\n        newContent: '=\"[]\"',\n      };\n    }\n    replacements.push(replacement);\n  }\n\n  return {originalTemplate: template, replacements, emptyRouterlinkExpressions};\n}\n"]}

package/schematics/migrations/{move-document → testbed-teardown}/index.d.ts

@@ -5,7 +5,7 @@
  * 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
  */
-/// <amd-module name="@angular/core/schematics/migrations/move-document" />
+/// <amd-module name="@angular/core/schematics/migrations/testbed-teardown" />
 import { Rule } from '@angular-devkit/schematics';
-/** Entry point for the V8 move-document migration. */
+/** Migration that adds the `teardown` flag to `TestBed` calls. */
 export default function (): Rule;

package/schematics/migrations/testbed-teardown/index.js

@@ -0,0 +1,92 @@
+/**
+ * @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
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/testbed-teardown", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/testbed-teardown/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular-devkit/schematics");
+    const path_1 = require("path");
+    const typescript_1 = __importDefault(require("typescript"));
+    const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
+    const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
+    const util_1 = require("@angular/core/schematics/migrations/testbed-teardown/util");
+    /** Migration that adds the `teardown` flag to `TestBed` calls. */
+    function default_1() {
+        return (tree) => __awaiter(this, void 0, void 0, function* () {
+            const { buildPaths, testPaths } = yield (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
+            const basePath = process.cwd();
+            const allPaths = [...buildPaths, ...testPaths];
+            if (!allPaths.length) {
+                throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot add `teardown` flag to `TestBed`.');
+            }
+            for (const tsconfigPath of allPaths) {
+                runTestbedTeardownMigration(tree, tsconfigPath, basePath);
+            }
+        });
+    }
+    exports.default = default_1;
+    function runTestbedTeardownMigration(tree, tsconfigPath, basePath) {
+        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+        const typeChecker = program.getTypeChecker();
+        const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
+        const initTestEnvironmentResult = (0, util_1.findInitTestEnvironmentCalls)(typeChecker, sourceFiles);
+        const printer = typescript_1.default.createPrinter();
+        // If we identified at least one call to `initTestEnvironment` (can be migrated or unmigrated),
+        // we don't need to migrate `configureTestingModule` or `withModule` calls, because they'll take
+        // the default teardown behavior from the environment. This is preferrable, because it'll result
+        // in the least number of changes to users' code.
+        if (initTestEnvironmentResult.totalCalls > 0) {
+            // Migrate all of the unmigrated calls `initTestEnvironment`. This could be zero
+            // if the user has already opted into the new teardown behavior themselves.
+            initTestEnvironmentResult.callsToMigrate.forEach(node => {
+                const { span, text } = (0, util_1.getInitTestEnvironmentLiteralReplacement)(node, printer);
+                const update = tree.beginUpdate((0, path_1.relative)(basePath, node.getSourceFile().fileName));
+                // The update appears to break if we try to call `remove` with a zero length.
+                if (span.length > 0) {
+                    update.remove(span.start, span.length);
+                }
+                update.insertRight(span.start, text);
+                tree.commitUpdate(update);
+            });
+        }
+        else {
+            // Otherwise migrate the metadata passed into the `configureTestingModule` and `withModule`
+            // calls. This scenario is less likely, but it could happen if `initTestEnvironment` has been
+            // abstracted away or is inside a .js file.
+            sourceFiles.forEach(sourceFile => {
+                (0, util_1.findTestModuleMetadataNodes)(typeChecker, sourceFile).forEach(node => {
+                    const migrated = (0, util_1.migrateTestModuleMetadataLiteral)(node);
+                    const update = tree.beginUpdate((0, path_1.relative)(basePath, node.getSourceFile().fileName));
+                    update.remove(node.getStart(), node.getWidth());
+                    update.insertRight(node.getStart(), printer.printNode(typescript_1.default.EmitHint.Unspecified, migrated, node.getSourceFile()));
+                    tree.commitUpdate(update);
+                });
+            });
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/testbed-teardown/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Rule, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {relative} from 'path';\nimport ts from 'typescript';\n\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {canMigrateFile, createMigrationProgram} from '../../utils/typescript/compiler_host';\nimport {findInitTestEnvironmentCalls, findTestModuleMetadataNodes, getInitTestEnvironmentLiteralReplacement, migrateTestModuleMetadataLiteral} from './util';\n\n\n/** Migration that adds the `teardown` flag to `TestBed` calls. */\nexport default function(): Rule {\n  return async (tree: Tree) => {\n    const {buildPaths, testPaths} = await getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n    const allPaths = [...buildPaths, ...testPaths];\n\n    if (!allPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot add `teardown` flag to `TestBed`.');\n    }\n\n    for (const tsconfigPath of allPaths) {\n      runTestbedTeardownMigration(tree, tsconfigPath, basePath);\n    }\n  };\n}\n\nfunction runTestbedTeardownMigration(tree: Tree, tsconfigPath: string, basePath: string) {\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath);\n  const typeChecker = program.getTypeChecker();\n  const sourceFiles =\n      program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));\n  const initTestEnvironmentResult = findInitTestEnvironmentCalls(typeChecker, sourceFiles);\n  const printer = ts.createPrinter();\n\n  // If we identified at least one call to `initTestEnvironment` (can be migrated or unmigrated),\n  // we don't need to migrate `configureTestingModule` or `withModule` calls, because they'll take\n  // the default teardown behavior from the environment. This is preferrable, because it'll result\n  // in the least number of changes to users' code.\n  if (initTestEnvironmentResult.totalCalls > 0) {\n    // Migrate all of the unmigrated calls `initTestEnvironment`. This could be zero\n    // if the user has already opted into the new teardown behavior themselves.\n    initTestEnvironmentResult.callsToMigrate.forEach(node => {\n      const {span, text} = getInitTestEnvironmentLiteralReplacement(node, printer);\n      const update = tree.beginUpdate(relative(basePath, node.getSourceFile().fileName));\n      // The update appears to break if we try to call `remove` with a zero length.\n      if (span.length > 0) {\n        update.remove(span.start, span.length);\n      }\n      update.insertRight(span.start, text);\n      tree.commitUpdate(update);\n    });\n  } else {\n    // Otherwise migrate the metadata passed into the `configureTestingModule` and `withModule`\n    // calls. This scenario is less likely, but it could happen if `initTestEnvironment` has been\n    // abstracted away or is inside a .js file.\n    sourceFiles.forEach(sourceFile => {\n      findTestModuleMetadataNodes(typeChecker, sourceFile).forEach(node => {\n        const migrated = migrateTestModuleMetadataLiteral(node);\n        const update = tree.beginUpdate(relative(basePath, node.getSourceFile().fileName));\n        update.remove(node.getStart(), node.getWidth());\n        update.insertRight(\n            node.getStart(),\n            printer.printNode(ts.EmitHint.Unspecified, migrated, node.getSourceFile()));\n        tree.commitUpdate(update);\n      });\n    });\n  }\n}\n"]}

package/schematics/migrations/testbed-teardown/util.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/core/schematics/migrations/testbed-teardown/util" />
+import ts from 'typescript';
+/** Result of a full-program analysis looking for `initTestEnvironment` calls. */
+export interface InitTestEnvironmentAnalysis {
+    /** Total number of calls that were found. */
+    totalCalls: number;
+    /** Calls that need to be migrated. */
+    callsToMigrate: ts.CallExpression[];
+}
+/** Finds the `initTestEnvironment` calls that need to be migrated. */
+export declare function findInitTestEnvironmentCalls(typeChecker: ts.TypeChecker, allSourceFiles: ts.SourceFile[]): InitTestEnvironmentAnalysis;
+/** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */
+export declare function findTestModuleMetadataNodes(typeChecker: ts.TypeChecker, sourceFile: ts.SourceFile): ts.ObjectLiteralExpression[];
+/**
+ * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.
+ * The returned `span` is used to mark the text that should be replaced while the `text`
+ * is the code that should be inserted instead.
+ */
+export declare function getInitTestEnvironmentLiteralReplacement(node: ts.CallExpression, printer: ts.Printer): {
+    span: {
+        start: number;
+        end: number;
+        length: number;
+    };
+    text: string;
+};
+/** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */
+export declare function migrateTestModuleMetadataLiteral(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpression;

package/schematics/migrations/testbed-teardown/util.js

@@ -0,0 +1,188 @@
+/**
+ * @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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/testbed-teardown/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/symbol"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.migrateTestModuleMetadataLiteral = exports.getInitTestEnvironmentLiteralReplacement = exports.findTestModuleMetadataNodes = exports.findInitTestEnvironmentCalls = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
+    const symbol_1 = require("@angular/core/schematics/utils/typescript/symbol");
+    /** Finds the `initTestEnvironment` calls that need to be migrated. */
+    function findInitTestEnvironmentCalls(typeChecker, allSourceFiles) {
+        const callsToMigrate = new Set();
+        let totalCalls = 0;
+        allSourceFiles.forEach(sourceFile => {
+            sourceFile.forEachChild(function walk(node) {
+                if (typescript_1.default.isCallExpression(node) && typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                    typescript_1.default.isIdentifier(node.expression.name) &&
+                    node.expression.name.text === 'initTestEnvironment' &&
+                    isTestBedAccess(typeChecker, node.expression)) {
+                    totalCalls++;
+                    if (shouldMigrateInitTestEnvironment(node)) {
+                        callsToMigrate.add(node);
+                    }
+                }
+                node.forEachChild(walk);
+            });
+        });
+        return {
+            // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of
+            // the file are migrated first). This avoids issues where a migrated node will offset the
+            // bounds of all nodes that come after it. Note that the nodes here are from all of the
+            // passed in source files, but that doesn't matter since the later nodes will still appear
+            // after the earlier ones.
+            callsToMigrate: sortInReverseSourceOrder(Array.from(callsToMigrate)),
+            totalCalls
+        };
+    }
+    exports.findInitTestEnvironmentCalls = findInitTestEnvironmentCalls;
+    /** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */
+    function findTestModuleMetadataNodes(typeChecker, sourceFile) {
+        const testModuleMetadataLiterals = new Set();
+        const withModuleImport = (0, imports_1.getImportSpecifier)(sourceFile, '@angular/core/testing', 'withModule');
+        sourceFile.forEachChild(function walk(node) {
+            if (typescript_1.default.isCallExpression(node)) {
+                const isConfigureTestingModuleCall = typescript_1.default.isPropertyAccessExpression(node.expression) &&
+                    typescript_1.default.isIdentifier(node.expression.name) &&
+                    node.expression.name.text === 'configureTestingModule' &&
+                    isTestBedAccess(typeChecker, node.expression) && shouldMigrateModuleConfigCall(node);
+                const isWithModuleCall = withModuleImport && typescript_1.default.isIdentifier(node.expression) &&
+                    (0, symbol_1.isReferenceToImport)(typeChecker, node.expression, withModuleImport) &&
+                    shouldMigrateModuleConfigCall(node);
+                if (isConfigureTestingModuleCall || isWithModuleCall) {
+                    testModuleMetadataLiterals.add(node.arguments[0]);
+                }
+            }
+            node.forEachChild(walk);
+        });
+        // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of
+        // the file are migrated first). This avoids issues where a migrated node will offset the
+        // bounds of all nodes that come after it.
+        return sortInReverseSourceOrder(Array.from(testModuleMetadataLiterals));
+    }
+    exports.findTestModuleMetadataNodes = findTestModuleMetadataNodes;
+    /**
+     * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.
+     * The returned `span` is used to mark the text that should be replaced while the `text`
+     * is the code that should be inserted instead.
+     */
+    function getInitTestEnvironmentLiteralReplacement(node, printer) {
+        const literalProperties = [];
+        const lastArg = node.arguments[node.arguments.length - 1];
+        let span;
+        let prefix;
+        if (node.arguments.length > 2) {
+            if (isFunction(lastArg)) {
+                // If the last argument is a function, add the function as the `aotSummaries` property.
+                literalProperties.push(typescript_1.default.createPropertyAssignment('aotSummaries', lastArg));
+            }
+            else if (typescript_1.default.isObjectLiteralExpression(lastArg)) {
+                // If the property is an object literal, copy over all the properties.
+                literalProperties.push(...lastArg.properties);
+            }
+            prefix = '';
+            span = { start: lastArg.getStart(), end: lastArg.getEnd(), length: lastArg.getWidth() };
+        }
+        else {
+            const start = lastArg.getEnd();
+            prefix = ', ';
+            span = { start, end: start, length: 0 };
+        }
+        // Finally push the teardown object so that it appears last.
+        literalProperties.push(createTeardownAssignment());
+        return {
+            span,
+            text: prefix +
+                printer.printNode(typescript_1.default.EmitHint.Unspecified, typescript_1.default.createObjectLiteral(literalProperties, true), node.getSourceFile())
+        };
+    }
+    exports.getInitTestEnvironmentLiteralReplacement = getInitTestEnvironmentLiteralReplacement;
+    /** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */
+    function migrateTestModuleMetadataLiteral(node) {
+        return typescript_1.default.createObjectLiteral([...node.properties, createTeardownAssignment()], node.properties.length > 0);
+    }
+    exports.migrateTestModuleMetadataLiteral = migrateTestModuleMetadataLiteral;
+    /** Returns whether a property access points to `TestBed`. */
+    function isTestBedAccess(typeChecker, node) {
+        var _a, _b;
+        const symbolName = (_b = (_a = typeChecker.getTypeAtLocation(node.expression)) === null || _a === void 0 ? void 0 : _a.getSymbol()) === null || _b === void 0 ? void 0 : _b.getName();
+        return symbolName === 'TestBed' || symbolName === 'TestBedStatic';
+    }
+    /** Whether a call to `initTestEnvironment` should be migrated. */
+    function shouldMigrateInitTestEnvironment(node) {
+        // If there is no third argument, we definitely have to migrate it.
+        if (node.arguments.length === 2) {
+            return true;
+        }
+        // This is technically a type error so we shouldn't mess with it.
+        if (node.arguments.length < 2) {
+            return false;
+        }
+        // Otherwise we need to figure out if the `teardown` flag is set on the last argument.
+        const lastArg = node.arguments[2];
+        // Note: the checks below will identify something like `initTestEnvironment(..., ..., {})`,
+        // but they'll ignore a variable being passed in as the last argument like `const config = {};
+        // initTestEnvironment(..., ..., config)`. While we can resolve the variable to its declaration
+        // using `typeChecker.getTypeAtLocation(lastArg).getSymbol()?.valueDeclaration`, we deliberately
+        // don't, because it introduces some complexity and we may end up breaking user code. E.g.
+        // the `config` from the example above may be passed in to other functions or the `teardown`
+        // flag could be added later on by a function call.
+        // If the argument is an object literal and there are no
+        // properties called `teardown`, we have to migrate it.
+        if (isObjectLiteralWithoutTeardown(lastArg)) {
+            return true;
+        }
+        // If the last argument is an `aotSummaries` function, we also have to migrate.
+        if (isFunction(lastArg)) {
+            return true;
+        }
+        // Otherwise don't migrate if we couldn't identify the last argument.
+        return false;
+    }
+    /**
+     * Whether a call to a module configuration function should be migrated. This covers
+     * `TestBed.configureTestingModule` and `withModule` since they both accept `TestModuleMetadata`
+     * as their first argument.
+     */
+    function shouldMigrateModuleConfigCall(node) {
+        return node.arguments.length > 0 && isObjectLiteralWithoutTeardown(node.arguments[0]);
+    }
+    /** Returns whether a node is a function literal. */
+    function isFunction(node) {
+        return typescript_1.default.isArrowFunction(node) || typescript_1.default.isFunctionExpression(node) ||
+            typescript_1.default.isFunctionDeclaration(node);
+    }
+    /** Checks whether a node is an object literal that doesn't contain a property called `teardown`. */
+    function isObjectLiteralWithoutTeardown(node) {
+        return typescript_1.default.isObjectLiteralExpression(node) && !node.properties.find(prop => {
+            var _a;
+            return ((_a = prop.name) === null || _a === void 0 ? void 0 : _a.getText()) === 'teardown';
+        });
+    }
+    /** Creates a teardown configuration property assignment. */
+    function createTeardownAssignment() {
+        // `teardown: {destroyAfterEach: false}`
+        return typescript_1.default.createPropertyAssignment('teardown', typescript_1.default.createObjectLiteral([typescript_1.default.createPropertyAssignment('destroyAfterEach', typescript_1.default.createFalse())]));
+    }
+    /** Sorts an array of AST nodes in reverse source order. */
+    function sortInReverseSourceOrder(nodes) {
+        return nodes.sort((a, b) => b.getEnd() - a.getEnd());
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/testbed-teardown/util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport ts from 'typescript';\n\nimport {getImportSpecifier} from '../../utils/typescript/imports';\nimport {isReferenceToImport} from '../../utils/typescript/symbol';\n\n/** Result of a full-program analysis looking for `initTestEnvironment` calls. */\nexport interface InitTestEnvironmentAnalysis {\n  /** Total number of calls that were found. */\n  totalCalls: number;\n  /** Calls that need to be migrated. */\n  callsToMigrate: ts.CallExpression[];\n}\n\n/** Finds the `initTestEnvironment` calls that need to be migrated. */\nexport function findInitTestEnvironmentCalls(\n    typeChecker: ts.TypeChecker, allSourceFiles: ts.SourceFile[]): InitTestEnvironmentAnalysis {\n  const callsToMigrate = new Set<ts.CallExpression>();\n  let totalCalls = 0;\n\n  allSourceFiles.forEach(sourceFile => {\n    sourceFile.forEachChild(function walk(node: ts.Node) {\n      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) &&\n          ts.isIdentifier(node.expression.name) &&\n          node.expression.name.text === 'initTestEnvironment' &&\n          isTestBedAccess(typeChecker, node.expression)) {\n        totalCalls++;\n        if (shouldMigrateInitTestEnvironment(node)) {\n          callsToMigrate.add(node);\n        }\n      }\n\n      node.forEachChild(walk);\n    });\n  });\n\n  return {\n    // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of\n    // the file are migrated first). This avoids issues where a migrated node will offset the\n    // bounds of all nodes that come after it. Note that the nodes here are from all of the\n    // passed in source files, but that doesn't matter since the later nodes will still appear\n    // after the earlier ones.\n    callsToMigrate: sortInReverseSourceOrder(Array.from(callsToMigrate)),\n    totalCalls\n  };\n}\n\n/** Finds the `configureTestingModule` and `withModule` calls that need to be migrated. */\nexport function findTestModuleMetadataNodes(\n    typeChecker: ts.TypeChecker, sourceFile: ts.SourceFile) {\n  const testModuleMetadataLiterals = new Set<ts.ObjectLiteralExpression>();\n  const withModuleImport = getImportSpecifier(sourceFile, '@angular/core/testing', 'withModule');\n\n  sourceFile.forEachChild(function walk(node: ts.Node) {\n    if (ts.isCallExpression(node)) {\n      const isConfigureTestingModuleCall = ts.isPropertyAccessExpression(node.expression) &&\n          ts.isIdentifier(node.expression.name) &&\n          node.expression.name.text === 'configureTestingModule' &&\n          isTestBedAccess(typeChecker, node.expression) && shouldMigrateModuleConfigCall(node);\n      const isWithModuleCall = withModuleImport && ts.isIdentifier(node.expression) &&\n          isReferenceToImport(typeChecker, node.expression, withModuleImport) &&\n          shouldMigrateModuleConfigCall(node);\n\n      if (isConfigureTestingModuleCall || isWithModuleCall) {\n        testModuleMetadataLiterals.add(node.arguments[0] as ts.ObjectLiteralExpression);\n      }\n    }\n\n    node.forEachChild(walk);\n  });\n\n  // Sort the nodes so that they will be migrated in reverse source order (nodes at the end of\n  // the file are migrated first). This avoids issues where a migrated node will offset the\n  // bounds of all nodes that come after it.\n  return sortInReverseSourceOrder(Array.from(testModuleMetadataLiterals));\n}\n\n/**\n * Gets data that can be used to migrate a call to `TestBed.initTestEnvironment`.\n * The returned `span` is used to mark the text that should be replaced while the `text`\n * is the code that should be inserted instead.\n */\nexport function getInitTestEnvironmentLiteralReplacement(\n    node: ts.CallExpression, printer: ts.Printer) {\n  const literalProperties: ts.ObjectLiteralElementLike[] = [];\n  const lastArg = node.arguments[node.arguments.length - 1];\n  let span: {start: number, end: number, length: number};\n  let prefix: string;\n\n  if (node.arguments.length > 2) {\n    if (isFunction(lastArg)) {\n      // If the last argument is a function, add the function as the `aotSummaries` property.\n      literalProperties.push(ts.createPropertyAssignment('aotSummaries', lastArg));\n    } else if (ts.isObjectLiteralExpression(lastArg)) {\n      // If the property is an object literal, copy over all the properties.\n      literalProperties.push(...lastArg.properties);\n    }\n\n    prefix = '';\n    span = {start: lastArg.getStart(), end: lastArg.getEnd(), length: lastArg.getWidth()};\n  } else {\n    const start = lastArg.getEnd();\n    prefix = ', ';\n    span = {start, end: start, length: 0};\n  }\n\n  // Finally push the teardown object so that it appears last.\n  literalProperties.push(createTeardownAssignment());\n\n  return {\n    span,\n    text: prefix +\n        printer.printNode(\n            ts.EmitHint.Unspecified, ts.createObjectLiteral(literalProperties, true),\n            node.getSourceFile())\n  };\n}\n\n/** Migrates an object literal that is passed into `configureTestingModule` or `withModule`. */\nexport function migrateTestModuleMetadataLiteral(node: ts.ObjectLiteralExpression):\n    ts.ObjectLiteralExpression {\n  return ts.createObjectLiteral(\n      [...node.properties, createTeardownAssignment()], node.properties.length > 0);\n}\n\n/** Returns whether a property access points to `TestBed`. */\nfunction isTestBedAccess(typeChecker: ts.TypeChecker, node: ts.PropertyAccessExpression): boolean {\n  const symbolName = typeChecker.getTypeAtLocation(node.expression)?.getSymbol()?.getName();\n  return symbolName === 'TestBed' || symbolName === 'TestBedStatic';\n}\n\n/** Whether a call to `initTestEnvironment` should be migrated. */\nfunction shouldMigrateInitTestEnvironment(node: ts.CallExpression): boolean {\n  // If there is no third argument, we definitely have to migrate it.\n  if (node.arguments.length === 2) {\n    return true;\n  }\n\n  // This is technically a type error so we shouldn't mess with it.\n  if (node.arguments.length < 2) {\n    return false;\n  }\n\n  // Otherwise we need to figure out if the `teardown` flag is set on the last argument.\n  const lastArg = node.arguments[2];\n\n  // Note: the checks below will identify something like `initTestEnvironment(..., ..., {})`,\n  // but they'll ignore a variable being passed in as the last argument like `const config = {};\n  // initTestEnvironment(..., ..., config)`. While we can resolve the variable to its declaration\n  // using `typeChecker.getTypeAtLocation(lastArg).getSymbol()?.valueDeclaration`, we deliberately\n  // don't, because it introduces some complexity and we may end up breaking user code. E.g.\n  // the `config` from the example above may be passed in to other functions or the `teardown`\n  // flag could be added later on by a function call.\n\n  // If the argument is an object literal and there are no\n  // properties called `teardown`, we have to migrate it.\n  if (isObjectLiteralWithoutTeardown(lastArg)) {\n    return true;\n  }\n\n  // If the last argument is an `aotSummaries` function, we also have to migrate.\n  if (isFunction(lastArg)) {\n    return true;\n  }\n\n  // Otherwise don't migrate if we couldn't identify the last argument.\n  return false;\n}\n\n/**\n * Whether a call to a module configuration function should be migrated. This covers\n * `TestBed.configureTestingModule` and `withModule` since they both accept `TestModuleMetadata`\n * as their first argument.\n */\nfunction shouldMigrateModuleConfigCall(node: ts.CallExpression): node is ts.CallExpression&\n    {arguments: [ts.ObjectLiteralExpression, ...ts.Expression[]]} {\n  return node.arguments.length > 0 && isObjectLiteralWithoutTeardown(node.arguments[0]);\n}\n\n/** Returns whether a node is a function literal. */\nfunction isFunction(node: ts.Node): node is ts.ArrowFunction|ts.FunctionExpression|\n    ts.FunctionDeclaration {\n  return ts.isArrowFunction(node) || ts.isFunctionExpression(node) ||\n      ts.isFunctionDeclaration(node);\n}\n\n/** Checks whether a node is an object literal that doesn't contain a property called `teardown`. */\nfunction isObjectLiteralWithoutTeardown(node: ts.Node): node is ts.ObjectLiteralExpression {\n  return ts.isObjectLiteralExpression(node) && !node.properties.find(prop => {\n    return prop.name?.getText() === 'teardown';\n  });\n}\n\n/** Creates a teardown configuration property assignment. */\nfunction createTeardownAssignment(): ts.PropertyAssignment {\n  // `teardown: {destroyAfterEach: false}`\n  return ts.createPropertyAssignment(\n      'teardown',\n      ts.createObjectLiteral([ts.createPropertyAssignment('destroyAfterEach', ts.createFalse())]));\n}\n\n/** Sorts an array of AST nodes in reverse source order. */\nfunction sortInReverseSourceOrder<T extends ts.Node>(nodes: T[]): T[] {\n  return nodes.sort((a, b) => b.getEnd() - a.getEnd());\n}\n"]}