| /** |
| * @license |
| * Copyright Google Inc. 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) { |
| 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } |
| step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| }); |
| }; |
| (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/static-queries", ["require", "exports", "@angular-devkit/schematics", "path", "rxjs", "typescript", "@angular/core/schematics/utils/ng_component_template", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/parse_tsconfig", "@angular/core/schematics/migrations/static-queries/angular/ng_query_visitor", "@angular/core/schematics/migrations/static-queries/strategies/template_strategy/template_strategy", "@angular/core/schematics/migrations/static-queries/strategies/test_strategy/test_strategy", "@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/usage_strategy", "@angular/core/schematics/migrations/static-queries/transform"], 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 rxjs_1 = require("rxjs"); |
| const ts = require("typescript"); |
| 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 parse_tsconfig_1 = require("@angular/core/schematics/utils/typescript/parse_tsconfig"); |
| const ng_query_visitor_1 = require("@angular/core/schematics/migrations/static-queries/angular/ng_query_visitor"); |
| const template_strategy_1 = require("@angular/core/schematics/migrations/static-queries/strategies/template_strategy/template_strategy"); |
| const test_strategy_1 = require("@angular/core/schematics/migrations/static-queries/strategies/test_strategy/test_strategy"); |
| const usage_strategy_1 = require("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/usage_strategy"); |
| const transform_1 = require("@angular/core/schematics/migrations/static-queries/transform"); |
| var SELECTED_STRATEGY; |
| (function (SELECTED_STRATEGY) { |
| SELECTED_STRATEGY[SELECTED_STRATEGY["TEMPLATE"] = 0] = "TEMPLATE"; |
| SELECTED_STRATEGY[SELECTED_STRATEGY["USAGE"] = 1] = "USAGE"; |
| SELECTED_STRATEGY[SELECTED_STRATEGY["TESTS"] = 2] = "TESTS"; |
| })(SELECTED_STRATEGY || (SELECTED_STRATEGY = {})); |
| /** Entry point for the V8 static-query migration. */ |
| function default_1() { |
| return (tree, context) => { |
| // We need to cast the returned "Observable" to "any" as there is a |
| // RxJS version mismatch that breaks the TS compilation. |
| return rxjs_1.from(runMigration(tree, context).then(() => tree)); |
| }; |
| } |
| exports.default = default_1; |
| /** Runs the V8 migration static-query migration for all determined TypeScript projects. */ |
| function runMigration(tree, context) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const { buildPaths, testPaths } = project_tsconfig_paths_1.getProjectTsConfigPaths(tree); |
| const basePath = process.cwd(); |
| const logger = context.logger; |
| logger.info('------ Static Query Migration ------'); |
| logger.info('With Angular version 8, developers need to'); |
| logger.info('explicitly specify the timing of ViewChild and'); |
| logger.info('ContentChild queries. Read more about this here:'); |
| logger.info('https://v8.angular.io/guide/static-query-migration'); |
| if (!buildPaths.length && !testPaths.length) { |
| throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot migrate queries ' + |
| 'to add static flag.'); |
| } |
| const analyzedFiles = new Set(); |
| const buildProjects = new Set(); |
| const failures = []; |
| const strategy = process.env['NG_STATIC_QUERY_USAGE_STRATEGY'] === 'true' ? |
| SELECTED_STRATEGY.USAGE : |
| SELECTED_STRATEGY.TEMPLATE; |
| for (const tsconfigPath of buildPaths) { |
| const project = analyzeProject(tree, tsconfigPath, basePath, analyzedFiles, logger); |
| if (project) { |
| buildProjects.add(project); |
| } |
| } |
| if (buildProjects.size) { |
| for (let project of Array.from(buildProjects.values())) { |
| failures.push(...yield runStaticQueryMigration(tree, project, strategy, logger)); |
| } |
| } |
| // For the "test" tsconfig projects we always want to use the test strategy as |
| // we can't detect the proper timing within spec files. |
| for (const tsconfigPath of testPaths) { |
| const project = yield analyzeProject(tree, tsconfigPath, basePath, analyzedFiles, logger); |
| if (project) { |
| failures.push(...yield runStaticQueryMigration(tree, project, SELECTED_STRATEGY.TESTS, logger)); |
| } |
| } |
| if (failures.length) { |
| logger.info(''); |
| logger.info('Some queries could not be migrated automatically. Please go'); |
| logger.info('through these manually and apply the appropriate timing.'); |
| logger.info('For more info on how to choose a flag, please see: '); |
| logger.info('https://v8.angular.io/guide/static-query-migration'); |
| failures.forEach(failure => logger.warn(`⮑ ${failure}`)); |
| } |
| logger.info('------------------------------------------------'); |
| }); |
| } |
| /** |
| * Analyzes the given TypeScript project by looking for queries that need to be |
| * migrated. In case there are no queries that can be migrated, null is returned. |
| */ |
| function analyzeProject(tree, tsconfigPath, basePath, analyzedFiles, logger) { |
| const parsed = parse_tsconfig_1.parseTsconfigFile(tsconfigPath, path_1.dirname(tsconfigPath)); |
| const host = ts.createCompilerHost(parsed.options, true); |
| // We need to overwrite the host "readFile" method, as we want the TypeScript |
| // program to be based on the file contents in the virtual file tree. Otherwise |
| // if we run the migration for multiple tsconfig files which have intersecting |
| // source files, it can end up updating query definitions multiple times. |
| host.readFile = fileName => { |
| const buffer = tree.read(path_1.relative(basePath, fileName)); |
| // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset which |
| // which breaks the CLI UpdateRecorder. |
| // See: https://github.com/angular/angular/pull/30719 |
| return buffer ? buffer.toString().replace(/^\uFEFF/, '') : undefined; |
| }; |
| const program = ts.createProgram(parsed.fileNames, parsed.options, host); |
| const syntacticDiagnostics = program.getSyntacticDiagnostics(); |
| // Syntactic TypeScript errors can throw off the query analysis and therefore we want |
| // to notify the developer that we couldn't analyze parts of the project. Developers |
| // can just re-run the migration after fixing these failures. |
| if (syntacticDiagnostics.length) { |
| logger.warn(`\nTypeScript project "${tsconfigPath}" has syntactical errors which could cause ` + |
| `an incomplete migration. Please fix the following failures and rerun the migration:`); |
| logger.error(ts.formatDiagnostics(syntacticDiagnostics, host)); |
| logger.info('Migration can be rerun with: "ng update @angular/core --from 7 --to 8 --migrate-only"\n'); |
| } |
| const typeChecker = program.getTypeChecker(); |
| const sourceFiles = program.getSourceFiles().filter(f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f)); |
| const queryVisitor = new ng_query_visitor_1.NgQueryResolveVisitor(typeChecker); |
| // Analyze all project source-files and collect all queries that |
| // need to be migrated. |
| sourceFiles.forEach(sourceFile => { |
| const relativePath = path_1.relative(basePath, sourceFile.fileName); |
| // Only look for queries within the current source files if the |
| // file has not been analyzed before. |
| if (!analyzedFiles.has(relativePath)) { |
| analyzedFiles.add(relativePath); |
| queryVisitor.visitNode(sourceFile); |
| } |
| }); |
| if (queryVisitor.resolvedQueries.size === 0) { |
| return null; |
| } |
| return { program, host, tsconfigPath, typeChecker, basePath, queryVisitor, sourceFiles }; |
| } |
| /** |
| * Runs the static query migration for the given project. The schematic analyzes all |
| * queries within the project and sets up the query timing based on the current usage |
| * of the query property. e.g. a view query that is not used in any lifecycle hook does |
| * not need to be static and can be set up with "static: false". |
| */ |
| function runStaticQueryMigration(tree, project, selectedStrategy, logger) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const { sourceFiles, typeChecker, host, queryVisitor, tsconfigPath, basePath } = project; |
| const printer = ts.createPrinter(); |
| const failureMessages = []; |
| const templateVisitor = new ng_component_template_1.NgComponentTemplateVisitor(typeChecker); |
| // If the "usage" strategy is selected, we also need to add the query visitor |
| // to the analysis visitors so that query usage in templates can be also checked. |
| if (selectedStrategy === SELECTED_STRATEGY.USAGE) { |
| sourceFiles.forEach(s => templateVisitor.visitNode(s)); |
| } |
| const { resolvedQueries, classMetadata } = queryVisitor; |
| const { resolvedTemplates } = templateVisitor; |
| if (selectedStrategy === SELECTED_STRATEGY.USAGE) { |
| // Add all resolved templates to the class metadata if the usage strategy is used. This |
| // is necessary in order to be able to check component templates for static query usage. |
| resolvedTemplates.forEach(template => { |
| if (classMetadata.has(template.container)) { |
| classMetadata.get(template.container).template = template; |
| } |
| }); |
| } |
| let strategy; |
| if (selectedStrategy === SELECTED_STRATEGY.USAGE) { |
| strategy = new usage_strategy_1.QueryUsageStrategy(classMetadata, typeChecker); |
| } |
| else if (selectedStrategy === SELECTED_STRATEGY.TESTS) { |
| strategy = new test_strategy_1.QueryTestStrategy(); |
| } |
| else { |
| strategy = new template_strategy_1.QueryTemplateStrategy(tsconfigPath, classMetadata, host); |
| } |
| try { |
| strategy.setup(); |
| } |
| catch (e) { |
| if (selectedStrategy === SELECTED_STRATEGY.TEMPLATE) { |
| logger.warn(`\nThe template migration strategy uses the Angular compiler ` + |
| `internally and therefore projects that no longer build successfully after ` + |
| `the update cannot use the template migration strategy. Please ensure ` + |
| `there are no AOT compilation errors.\n`); |
| } |
| // In case the strategy could not be set up properly, we just exit the |
| // migration. We don't want to throw an exception as this could mean |
| // that other migrations are interrupted. |
| logger.warn(`Could not setup migration strategy for "${project.tsconfigPath}". The ` + |
| `following error has been reported:\n`); |
| logger.error(`${e.toString()}\n`); |
| logger.info('Migration can be rerun with: "ng update @angular/core --from 7 --to 8 --migrate-only"\n'); |
| return []; |
| } |
| // Walk through all source files that contain resolved queries and update |
| // the source files if needed. Note that we need to update multiple queries |
| // within a source file within the same recorder in order to not throw off |
| // the TypeScript node offsets. |
| resolvedQueries.forEach((queries, sourceFile) => { |
| const relativePath = path_1.relative(basePath, sourceFile.fileName); |
| const update = tree.beginUpdate(relativePath); |
| // Compute the query timing for all resolved queries and update the |
| // query definitions to explicitly set the determined query timing. |
| queries.forEach(q => { |
| const queryExpr = q.decorator.node.expression; |
| const { timing, message } = strategy.detectTiming(q); |
| const result = transform_1.getTransformedQueryCallExpr(q, timing, !!message); |
| if (!result) { |
| return; |
| } |
| const newText = printer.printNode(ts.EmitHint.Unspecified, result.node, sourceFile); |
| // Replace the existing query decorator call expression with the updated |
| // call expression node. |
| update.remove(queryExpr.getStart(), queryExpr.getWidth()); |
| update.insertRight(queryExpr.getStart(), newText); |
| if (result.failureMessage || message) { |
| const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, q.decorator.node.getStart()); |
| failureMessages.push(`${relativePath}@${line + 1}:${character + 1}: ${result.failureMessage || message}`); |
| } |
| }); |
| tree.commitUpdate(update); |
| }); |
| return failureMessages; |
| }); |
| } |
| }); |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/static-queries/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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} from '@angular-devkit/core';\nimport {Rule, SchematicContext, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {dirname, relative} from 'path';\nimport {from} from 'rxjs';\nimport * as ts from 'typescript';\n\nimport {NgComponentTemplateVisitor} from '../../utils/ng_component_template';\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {parseTsconfigFile} from '../../utils/typescript/parse_tsconfig';\n\nimport {NgQueryResolveVisitor} from './angular/ng_query_visitor';\nimport {QueryTemplateStrategy} from './strategies/template_strategy/template_strategy';\nimport {QueryTestStrategy} from './strategies/test_strategy/test_strategy';\nimport {TimingStrategy} from './strategies/timing-strategy';\nimport {QueryUsageStrategy} from './strategies/usage_strategy/usage_strategy';\nimport {getTransformedQueryCallExpr} from './transform';\n\nenum SELECTED_STRATEGY {\n  TEMPLATE,\n  USAGE,\n  TESTS,\n}\n\ninterface AnalyzedProject {\n  program: ts.Program;\n  host: ts.CompilerHost;\n  queryVisitor: NgQueryResolveVisitor;\n  sourceFiles: ts.SourceFile[];\n  basePath: string;\n  typeChecker: ts.TypeChecker;\n  tsconfigPath: string;\n}\n\n/** Entry point for the V8 static-query migration. */\nexport default function(): Rule {\n  return (tree: Tree, context: SchematicContext) => {\n    // We need to cast the returned \"Observable\" to \"any\" as there is a\n    // RxJS version mismatch that breaks the TS compilation.\n    return from(runMigration(tree, context).then(() => tree)) as any;\n  };\n}\n\n/** Runs the V8 migration static-query migration for all determined TypeScript projects. */\nasync function runMigration(tree: Tree, context: SchematicContext) {\n  const {buildPaths, testPaths} = getProjectTsConfigPaths(tree);\n  const basePath = process.cwd();\n  const logger = context.logger;\n\n  logger.info('------ Static Query Migration ------');\n  logger.info('With Angular version 8, developers need to');\n  logger.info('explicitly specify the timing of ViewChild and');\n  logger.info('ContentChild queries. Read more about this here:');\n  logger.info('https://v8.angular.io/guide/static-query-migration');\n\n  if (!buildPaths.length && !testPaths.length) {\n    throw new SchematicsException(\n        'Could not find any tsconfig file. Cannot migrate queries ' +\n        'to add static flag.');\n  }\n\n  const analyzedFiles = new Set<string>();\n  const buildProjects = new Set<AnalyzedProject>();\n  const failures = [];\n  const strategy = process.env['NG_STATIC_QUERY_USAGE_STRATEGY'] === 'true' ?\n      SELECTED_STRATEGY.USAGE :\n      SELECTED_STRATEGY.TEMPLATE;\n\n  for (const tsconfigPath of buildPaths) {\n    const project = analyzeProject(tree, tsconfigPath, basePath, analyzedFiles, logger);\n    if (project) {\n      buildProjects.add(project);\n    }\n  }\n\n  if (buildProjects.size) {\n    for (let project of Array.from(buildProjects.values())) {\n      failures.push(...await runStaticQueryMigration(tree, project, strategy, logger));\n    }\n  }\n\n  // For the \"test\" tsconfig projects we always want to use the test strategy as\n  // we can't detect the proper timing within spec files.\n  for (const tsconfigPath of testPaths) {\n    const project = await analyzeProject(tree, tsconfigPath, basePath, analyzedFiles, logger);\n    if (project) {\n      failures.push(\n          ...await runStaticQueryMigration(tree, project, SELECTED_STRATEGY.TESTS, logger));\n    }\n  }\n\n  if (failures.length) {\n    logger.info('');\n    logger.info('Some queries could not be migrated automatically. Please go');\n    logger.info('through these manually and apply the appropriate timing.');\n    logger.info('For more info on how to choose a flag, please see: ');\n    logger.info('https://v8.angular.io/guide/static-query-migration');\n    failures.forEach(failure => logger.warn(`⮑   ${failure}`));\n  }\n\n  logger.info('------------------------------------------------');\n}\n\n/**\n * Analyzes the given TypeScript project by looking for queries that need to be\n * migrated. In case there are no queries that can be migrated, null is returned.\n */\nfunction analyzeProject(\n    tree: Tree, tsconfigPath: string, basePath: string, analyzedFiles: Set<string>,\n    logger: logging.LoggerApi):\n    AnalyzedProject|null {\n      const parsed = parseTsconfigFile(tsconfigPath, dirname(tsconfigPath));\n      const host = ts.createCompilerHost(parsed.options, true);\n\n      // We need to overwrite the host \"readFile\" method, as we want the TypeScript\n      // program to be based on the file contents in the virtual file tree. Otherwise\n      // if we run the migration for multiple tsconfig files which have intersecting\n      // source files, it can end up updating query definitions multiple times.\n      host.readFile = fileName => {\n        const buffer = tree.read(relative(basePath, fileName));\n        // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset which\n        // which breaks the CLI UpdateRecorder.\n        // See: https://github.com/angular/angular/pull/30719\n        return buffer ? buffer.toString().replace(/^\\uFEFF/, '') : undefined;\n      };\n\n      const program = ts.createProgram(parsed.fileNames, parsed.options, host);\n      const syntacticDiagnostics = program.getSyntacticDiagnostics();\n\n      // Syntactic TypeScript errors can throw off the query analysis and therefore we want\n      // to notify the developer that we couldn't analyze parts of the project. Developers\n      // can just re-run the migration after fixing these failures.\n      if (syntacticDiagnostics.length) {\n        logger.warn(\n            `\\nTypeScript project \"${tsconfigPath}\" has syntactical errors which could cause ` +\n            `an incomplete migration. Please fix the following failures and rerun the migration:`);\n        logger.error(ts.formatDiagnostics(syntacticDiagnostics, host));\n        logger.info(\n            'Migration can be rerun with: \"ng update @angular/core --from 7 --to 8 --migrate-only\"\\n');\n      }\n\n      const typeChecker = program.getTypeChecker();\n      const sourceFiles = program.getSourceFiles().filter(\n          f => !f.isDeclarationFile && !program.isSourceFileFromExternalLibrary(f));\n      const queryVisitor = new NgQueryResolveVisitor(typeChecker);\n\n      // Analyze all project source-files and collect all queries that\n      // need to be migrated.\n      sourceFiles.forEach(sourceFile => {\n        const relativePath = relative(basePath, sourceFile.fileName);\n\n        // Only look for queries within the current source files if the\n        // file has not been analyzed before.\n        if (!analyzedFiles.has(relativePath)) {\n          analyzedFiles.add(relativePath);\n          queryVisitor.visitNode(sourceFile);\n        }\n      });\n\n      if (queryVisitor.resolvedQueries.size === 0) {\n        return null;\n      }\n\n      return {program, host, tsconfigPath, typeChecker, basePath, queryVisitor, sourceFiles};\n    }\n\n/**\n * Runs the static query migration for the given project. The schematic analyzes all\n * queries within the project and sets up the query timing based on the current usage\n * of the query property. e.g. a view query that is not used in any lifecycle hook does\n * not need to be static and can be set up with \"static: false\".\n */\nasync function runStaticQueryMigration(\n    tree: Tree, project: AnalyzedProject, selectedStrategy: SELECTED_STRATEGY,\n    logger: logging.LoggerApi): Promise<string[]> {\n  const {sourceFiles, typeChecker, host, queryVisitor, tsconfigPath, basePath} = project;\n  const printer = ts.createPrinter();\n  const failureMessages: string[] = [];\n  const templateVisitor = new NgComponentTemplateVisitor(typeChecker);\n\n  // If the \"usage\" strategy is selected, we also need to add the query visitor\n  // to the analysis visitors so that query usage in templates can be also checked.\n  if (selectedStrategy === SELECTED_STRATEGY.USAGE) {\n    sourceFiles.forEach(s => templateVisitor.visitNode(s));\n  }\n\n  const {resolvedQueries, classMetadata} = queryVisitor;\n  const {resolvedTemplates} = templateVisitor;\n\n  if (selectedStrategy === SELECTED_STRATEGY.USAGE) {\n    // Add all resolved templates to the class metadata if the usage strategy is used. This\n    // is necessary in order to be able to check component templates for static query usage.\n    resolvedTemplates.forEach(template => {\n      if (classMetadata.has(template.container)) {\n        classMetadata.get(template.container) !.template = template;\n      }\n    });\n  }\n\n  let strategy: TimingStrategy;\n  if (selectedStrategy === SELECTED_STRATEGY.USAGE) {\n    strategy = new QueryUsageStrategy(classMetadata, typeChecker);\n  } else if (selectedStrategy === SELECTED_STRATEGY.TESTS) {\n    strategy = new QueryTestStrategy();\n  } else {\n    strategy = new QueryTemplateStrategy(tsconfigPath, classMetadata, host);\n  }\n\n  try {\n    strategy.setup();\n  } catch (e) {\n    if (selectedStrategy === SELECTED_STRATEGY.TEMPLATE) {\n      logger.warn(\n          `\\nThe template migration strategy uses the Angular compiler ` +\n          `internally and therefore projects that no longer build successfully after ` +\n          `the update cannot use the template migration strategy. Please ensure ` +\n          `there are no AOT compilation errors.\\n`);\n    }\n    // In case the strategy could not be set up properly, we just exit the\n    // migration. We don't want to throw an exception as this could mean\n    // that other migrations are interrupted.\n    logger.warn(\n        `Could not setup migration strategy for \"${project.tsconfigPath}\". The ` +\n        `following error has been reported:\\n`);\n    logger.error(`${e.toString()}\\n`);\n    logger.info(\n        'Migration can be rerun with: \"ng update @angular/core --from 7 --to 8 --migrate-only\"\\n');\n    return [];\n  }\n\n  // Walk through all source files that contain resolved queries and update\n  // the source files if needed. Note that we need to update multiple queries\n  // within a source file within the same recorder in order to not throw off\n  // the TypeScript node offsets.\n  resolvedQueries.forEach((queries, sourceFile) => {\n    const relativePath = relative(basePath, sourceFile.fileName);\n    const update = tree.beginUpdate(relativePath);\n\n    // Compute the query timing for all resolved queries and update the\n    // query definitions to explicitly set the determined query timing.\n    queries.forEach(q => {\n      const queryExpr = q.decorator.node.expression;\n      const {timing, message} = strategy.detectTiming(q);\n      const result = getTransformedQueryCallExpr(q, timing, !!message);\n\n      if (!result) {\n        return;\n      }\n\n      const newText = printer.printNode(ts.EmitHint.Unspecified, result.node, sourceFile);\n\n      // Replace the existing query decorator call expression with the updated\n      // call expression node.\n      update.remove(queryExpr.getStart(), queryExpr.getWidth());\n      update.insertRight(queryExpr.getStart(), newText);\n\n      if (result.failureMessage || message) {\n        const {line, character} =\n            ts.getLineAndCharacterOfPosition(sourceFile, q.decorator.node.getStart());\n        failureMessages.push(\n            `${relativePath}@${line + 1}:${character + 1}: ${result.failureMessage || message}`);\n      }\n    });\n\n    tree.commitUpdate(update);\n  });\n\n  return failureMessages;\n}\n"]} |