@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/schematics/migrations/template-var-assignment/angular/html_variable_assignment_visitor.js

@@ -11,28 +11,48 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/migrations/template-var-assignment/angular/html_variable_assignment_visitor", ["require", "exports", "@angular/compiler", "@angular/compiler/src/render3/r3_ast"], factory);
+        define("@angular/core/schematics/migrations/template-var-assignment/angular/html_variable_assignment_visitor", ["require", "exports", "@angular/core/schematics/utils/template_ast_visitor"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.HtmlVariableAssignmentVisitor = 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
      * expressions that write to local template variables within bound events.
      */
-    class HtmlVariableAssignmentVisitor extends r3_ast_1.NullVisitor {
-        constructor() {
-            super(...arguments);
+    class HtmlVariableAssignmentVisitor extends template_ast_visitor_1.TemplateAstVisitor {
+        constructor(compilerModule) {
+            super(compilerModule);
             this.variableAssignments = [];
             this.currentVariables = [];
-            this.expressionAstVisitor = new ExpressionAstVisitor(this.variableAssignments, this.currentVariables);
+            // AST visitor that resolves all variable assignments within a given expression AST.
+            // This class must be defined within the template visitor due to the need to extend from a class
+            // value found within `@angular/compiler` which is dynamically imported and provided to the
+            // visitor.
+            this.expressionAstVisitor = new (class extends compilerModule.RecursiveAstVisitor {
+                constructor(variableAssignments, currentVariables) {
+                    super();
+                    this.variableAssignments = variableAssignments;
+                    this.currentVariables = currentVariables;
+                }
+                visitPropertyWrite(node, span) {
+                    if (node.receiver instanceof compilerModule.ImplicitReceiver &&
+                        this.currentVariables.some(v => v.name === node.name)) {
+                        this.variableAssignments.push({
+                            node: node,
+                            start: span.start.offset,
+                            end: span.end.offset,
+                        });
+                    }
+                    super.visitPropertyWrite(node, span);
+                }
+            })(this.variableAssignments, this.currentVariables);
         }
         visitElement(element) {
-            r3_ast_1.visitAll(this, element.outputs);
-            r3_ast_1.visitAll(this, element.children);
+            this.visitAll(element.outputs);
+            this.visitAll(element.children);
         }
         visitTemplate(template) {
             // Keep track of the template variables which can be accessed by the template
@@ -41,7 +61,7 @@
             // Visit all children of the template. The template proxies the outputs of the
             // immediate child elements, so we just ignore outputs on the "Template" in order
             // to not visit similar bound events twice.
-            r3_ast_1.visitAll(this, template.children);
+            this.visitAll(template.children);
             // Remove all previously added variables since all children that could access
             // these have been visited already.
             template.variables.forEach(v => {
@@ -56,24 +76,5 @@
         }
     }
     exports.HtmlVariableAssignmentVisitor = HtmlVariableAssignmentVisitor;
-    /** AST visitor that resolves all variable assignments within a given expression AST. */
-    class ExpressionAstVisitor extends compiler_1.RecursiveAstVisitor {
-        constructor(variableAssignments, currentVariables) {
-            super();
-            this.variableAssignments = variableAssignments;
-            this.currentVariables = currentVariables;
-        }
-        visitPropertyWrite(node, span) {
-            if (node.receiver instanceof compiler_1.ImplicitReceiver &&
-                this.currentVariables.some(v => v.name === node.name)) {
-                this.variableAssignments.push({
-                    node: node,
-                    start: span.start.offset,
-                    end: span.end.offset,
-                });
-            }
-            super.visitPropertyWrite(node, span);
-        }
-    }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/template-var-assignment/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/template-var-assignment", ["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/template-var-assignment/analyze_template"], factory);
+        define("@angular/core/schematics/migrations/template-var-assignment", ["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/template-var-assignment/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");
@@ -37,14 +38,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     /** Entry point for the V8 template variable assignment schematic. */
     function default_1() {
         return (tree, context) => __awaiter(this, void 0, void 0, function* () {
-            const { buildPaths, testPaths } = yield project_tsconfig_paths_1.getProjectTsConfigPaths(tree);
+            const { buildPaths, testPaths } = yield (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
             const basePath = process.cwd();
             if (!buildPaths.length && !testPaths.length) {
                 throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot check templates for template variable ' +
                     'assignments.');
             }
+            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]) {
-                runTemplateVariableAssignmentCheck(tree, tsconfigPath, basePath, context.logger);
+                runTemplateVariableAssignmentCheck(tree, tsconfigPath, basePath, context.logger, compilerModule);
             }
         });
     }
@@ -53,11 +64,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
      * Runs the template variable assignment check. Warns developers
      * if values are assigned to template variables within output bindings.
      */
-    function runTemplateVariableAssignmentCheck(tree, tsconfigPath, basePath, logger) {
-        const { program } = compiler_host_1.createMigrationProgram(tree, tsconfigPath, basePath);
+    function runTemplateVariableAssignmentCheck(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);
-        const sourceFiles = program.getSourceFiles().filter(sourceFile => compiler_host_1.canMigrateFile(basePath, sourceFile, program));
+        const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
         // Analyze source files by detecting HTML templates.
         sourceFiles.forEach(sourceFile => templateVisitor.visitNode(sourceFile));
         const { resolvedTemplates } = templateVisitor;
@@ -66,11 +77,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         // template variables.
         resolvedTemplates.forEach(template => {
             const filePath = template.filePath;
-            const nodes = analyze_template_1.analyzeResolvedTemplate(template);
+            const nodes = (0, analyze_template_1.analyzeResolvedTemplate)(template, compilerModule);
             if (!nodes) {
                 return;
             }
-            const displayFilePath = core_1.normalize(path_1.relative(basePath, filePath));
+            const displayFilePath = (0, core_1.normalize)((0, path_1.relative)(basePath, filePath));
             nodes.forEach(n => {
                 const { line, character } = template.getCharacterAndLineOfPosition(n.start);
                 collectedFailures.push(`${displayFilePath}@${line + 1}:${character + 1}: ${FAILURE_MESSAGE}`);
@@ -87,4 +98,4 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
     }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/template-var-assignment/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;IAEH,+CAAwD;IACxD,2DAA6F;IAC7F,+BAA8B;IAE9B,sEAAmD;IACnD,gGAA6E;IAC7E,kGAA2E;IAC3E,2FAA4F;IAE5F,mHAA2D;IAI3D,MAAM,UAAU,GAAG,8EAA8E,CAAC;IAClG,MAAM,eAAe,GAAG,wCAAwC,CAAC;IAEjE,qEAAqE;IACrE;QACE,OAAO,CAAO,IAAU,EAAE,OAAyB,EAAE,EAAE;YACrD,MAAM,EAAC,UAAU,EAAE,SAAS,EAAC,GAAG,MAAM,IAAA,gDAAuB,EAAC,IAAI,CAAC,CAAC;YACpE,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;YAE/B,IAAI,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;gBAC3C,MAAM,IAAI,gCAAmB,CACzB,iFAAiF;oBACjF,cAAc,CAAC,CAAC;aACrB;YAED,IAAI,cAAc,CAAC;YACnB,IAAI;gBACF,+EAA+E;gBAC/E,yFAAyF;gBACzF,sCAAsC;gBACtC,cAAc,GAAG,MAAM,IAAA,wBAAa,EAAqC,mBAAmB,CAAC,CAAC;aAC/F;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,gCAAmB,CACzB,4DAA4D,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;aAC9E;YAED,KAAK,MAAM,YAAY,IAAI,CAAC,GAAG,UAAU,EAAE,GAAG,SAAS,CAAC,EAAE;gBACxD,kCAAkC,CAC9B,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;aACnE;QACH,CAAC,CAAA,CAAC;IACJ,CAAC;IA3BD,4BA2BC;IAED;;;OAGG;IACH,SAAS,kCAAkC,CACvC,IAAU,EAAE,YAAoB,EAAE,QAAgB,EAAE,MAAc,EAClE,cAAkD;QACpD,MAAM,EAAC,OAAO,EAAC,GAAG,IAAA,sCAAsB,EAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC;QACvE,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;QAC7C,MAAM,eAAe,GAAG,IAAI,kDAA0B,CAAC,WAAW,CAAC,CAAC;QACpE,MAAM,WAAW,GACb,OAAO,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,IAAA,8BAAc,EAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;QAEjG,oDAAoD;QACpD,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;QAEzE,MAAM,EAAC,iBAAiB,EAAC,GAAG,eAAe,CAAC;QAC5C,MAAM,iBAAiB,GAAa,EAAE,CAAC;QAEvC,4EAA4E;QAC5E,sBAAsB;QACtB,iBAAiB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACnC,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;YACnC,MAAM,KAAK,GAAG,IAAA,0CAAuB,EAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YAEhE,IAAI,CAAC,KAAK,EAAE;gBACV,OAAO;aACR;YAED,MAAM,eAAe,GAAG,IAAA,gBAAS,EAAC,IAAA,eAAQ,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YAEhE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAChB,MAAM,EAAC,IAAI,EAAE,SAAS,EAAC,GAAG,QAAQ,CAAC,6BAA6B,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC1E,iBAAiB,CAAC,IAAI,CAAC,GAAG,eAAe,IAAI,IAAI,GAAG,CAAC,IAAI,SAAS,GAAG,CAAC,KAAK,eAAe,EAAE,CAAC,CAAC;YAChG,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,iBAAiB,CAAC,MAAM,EAAE;YAC5B,MAAM,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;YAChE,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;YACjF,MAAM,CAAC,IAAI,CAAC,sEAAsE,CAAC,CAAC;YACpF,MAAM,CAAC,IAAI,CAAC,qBAAqB,UAAU,EAAE,CAAC,CAAC;YAC/C,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;YAC9D,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,EAAE,CAAC,CAAC,CAAC;SACrE;IACH,CAAC","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 {relative} from 'path';\n\nimport {loadEsmModule} from '../../utils/load_esm';\nimport {NgComponentTemplateVisitor} 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 = 'https://v8.angular.io/guide/deprecations#cannot-assign-to-template-variables';\nconst FAILURE_MESSAGE = `Found assignment to template variable.`;\n\n/** Entry point for the V8 template variable assignment schematic. */\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 template variable ' +\n          'assignments.');\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      runTemplateVariableAssignmentCheck(\n          tree, tsconfigPath, basePath, context.logger, compilerModule);\n    }\n  };\n}\n\n/**\n * Runs the template variable assignment check. Warns developers\n * if values are assigned to template variables within output bindings.\n */\nfunction runTemplateVariableAssignmentCheck(\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  const collectedFailures: string[] = [];\n\n  // Analyze each resolved template and print a warning for property writes to\n  // template variables.\n  resolvedTemplates.forEach(template => {\n    const filePath = template.filePath;\n    const nodes = analyzeResolvedTemplate(template, compilerModule);\n\n    if (!nodes) {\n      return;\n    }\n\n    const displayFilePath = normalize(relative(basePath, filePath));\n\n    nodes.forEach(n => {\n      const {line, character} = template.getCharacterAndLineOfPosition(n.start);\n      collectedFailures.push(`${displayFilePath}@${line + 1}:${character + 1}: ${FAILURE_MESSAGE}`);\n    });\n  });\n\n  if (collectedFailures.length) {\n    logger.info('---- Template Variable Assignment schematic ----');\n    logger.info('Assignments to template variables will no longer work with Ivy as');\n    logger.info('template variables are effectively constants in Ivy. Read more about');\n    logger.info(`this change here: ${README_URL}`);\n    logger.info('');\n    logger.info('The following template assignments were found:');\n    collectedFailures.forEach(failure => logger.warn(`⮑   ${failure}`));\n  }\n}\n"]}

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

@@ -0,0 +1,11 @@
+/**
+ * @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" />
+import { Rule } from '@angular-devkit/schematics';
+/** 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"]}