| /** |
| * @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 |
| */ |
| (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/missing-injectable/transform", ["require", "exports", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/src/ngtsc/partial_evaluator", "@angular/compiler-cli/src/ngtsc/reflection", "typescript", "@angular/core/schematics/utils/import_manager", "@angular/core/schematics/utils/ng_decorators", "@angular/core/schematics/migrations/missing-injectable/providers_evaluator"], factory); |
| } |
| })(function (require, exports) { |
| "use strict"; |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| exports.MissingInjectableTransform = void 0; |
| const imports_1 = require("@angular/compiler-cli/src/ngtsc/imports"); |
| const partial_evaluator_1 = require("@angular/compiler-cli/src/ngtsc/partial_evaluator"); |
| const reflection_1 = require("@angular/compiler-cli/src/ngtsc/reflection"); |
| const ts = require("typescript"); |
| const import_manager_1 = require("@angular/core/schematics/utils/import_manager"); |
| const ng_decorators_1 = require("@angular/core/schematics/utils/ng_decorators"); |
| const providers_evaluator_1 = require("@angular/core/schematics/migrations/missing-injectable/providers_evaluator"); |
| /** |
| * Name of decorators which imply that a given class does not need to be migrated. |
| * - `@Injectable`, `@Directive`, `@Component` and `@Pipe` instruct the compiler |
| * to generate a factory definition. |
| * - `@NgModule` instructs the compiler to generate a provider definition that holds |
| * the factory function. |
| */ |
| const NO_MIGRATE_DECORATORS = ['Injectable', 'Directive', 'Component', 'Pipe', 'NgModule']; |
| class MissingInjectableTransform { |
| constructor(typeChecker, getUpdateRecorder) { |
| this.typeChecker = typeChecker; |
| this.getUpdateRecorder = getUpdateRecorder; |
| this.printer = ts.createPrinter(); |
| this.importManager = new import_manager_1.ImportManager(this.getUpdateRecorder, this.printer); |
| /** Set of provider class declarations which were already checked or migrated. */ |
| this.visitedProviderClasses = new Set(); |
| /** Set of provider object literals which were already checked or migrated. */ |
| this.visitedProviderLiterals = new Set(); |
| this.providersEvaluator = new providers_evaluator_1.ProvidersEvaluator(new reflection_1.TypeScriptReflectionHost(typeChecker), typeChecker, /* dependencyTracker */ null); |
| } |
| recordChanges() { |
| this.importManager.recordChanges(); |
| } |
| /** |
| * Migrates all specified NgModule's by walking through referenced providers |
| * and decorating them with "@Injectable" if needed. |
| */ |
| migrateModules(modules) { |
| return modules.reduce((failures, node) => failures.concat(this.migrateModule(node)), []); |
| } |
| /** |
| * Migrates all specified directives by walking through referenced providers |
| * and decorating them with "@Injectable" if needed. |
| */ |
| migrateDirectives(directives) { |
| return directives.reduce((failures, node) => failures.concat(this.migrateDirective(node)), []); |
| } |
| /** Migrates a given NgModule by walking through the referenced providers. */ |
| migrateModule(module) { |
| if (module.providersExpr === null) { |
| return []; |
| } |
| const { resolvedValue, literals } = this.providersEvaluator.evaluate(module.providersExpr); |
| this._migrateLiteralProviders(literals); |
| if (!Array.isArray(resolvedValue)) { |
| return [ |
| { node: module.providersExpr, message: 'Providers of module are not statically analyzable.' } |
| ]; |
| } |
| return this._visitProviderResolvedValue(resolvedValue, module); |
| } |
| /** |
| * Migrates a given directive by walking through defined providers. This method |
| * also handles components with "viewProviders" defined. |
| */ |
| migrateDirective(directive) { |
| const failures = []; |
| // Migrate "providers" on directives and components if defined. |
| if (directive.providersExpr) { |
| const { resolvedValue, literals } = this.providersEvaluator.evaluate(directive.providersExpr); |
| this._migrateLiteralProviders(literals); |
| if (!Array.isArray(resolvedValue)) { |
| return [ |
| { node: directive.providersExpr, message: `Providers are not statically analyzable.` } |
| ]; |
| } |
| failures.push(...this._visitProviderResolvedValue(resolvedValue, directive)); |
| } |
| // Migrate "viewProviders" on components if defined. |
| if (directive.viewProvidersExpr) { |
| const { resolvedValue, literals } = this.providersEvaluator.evaluate(directive.viewProvidersExpr); |
| this._migrateLiteralProviders(literals); |
| if (!Array.isArray(resolvedValue)) { |
| return [ |
| { node: directive.viewProvidersExpr, message: `Providers are not statically analyzable.` } |
| ]; |
| } |
| failures.push(...this._visitProviderResolvedValue(resolvedValue, directive)); |
| } |
| return failures; |
| } |
| /** |
| * Migrates a given provider class if it is not decorated with |
| * any Angular decorator. |
| */ |
| migrateProviderClass(node, context) { |
| if (this.visitedProviderClasses.has(node)) { |
| return; |
| } |
| this.visitedProviderClasses.add(node); |
| const sourceFile = node.getSourceFile(); |
| // We cannot migrate provider classes outside of source files. This is because the |
| // migration for third-party library files should happen in "ngcc", and in general |
| // would also involve metadata parsing. |
| if (sourceFile.isDeclarationFile) { |
| return; |
| } |
| const ngDecorators = node.decorators ? ng_decorators_1.getAngularDecorators(this.typeChecker, node.decorators) : null; |
| if (ngDecorators !== null && |
| ngDecorators.some(d => NO_MIGRATE_DECORATORS.indexOf(d.name) !== -1)) { |
| return; |
| } |
| const updateRecorder = this.getUpdateRecorder(sourceFile); |
| const importExpr = this.importManager.addImportToSourceFile(sourceFile, 'Injectable', '@angular/core'); |
| const newDecoratorExpr = ts.createDecorator(ts.createCall(importExpr, undefined, undefined)); |
| const newDecoratorText = this.printer.printNode(ts.EmitHint.Unspecified, newDecoratorExpr, sourceFile); |
| // In case the class is already decorated with "@Inject(..)", we replace the "@Inject" |
| // decorator with "@Injectable()" since using "@Inject(..)" on a class is a noop and |
| // most likely was meant to be "@Injectable()". |
| const existingInjectDecorator = ngDecorators !== null ? ngDecorators.find(d => d.name === 'Inject') : null; |
| if (existingInjectDecorator) { |
| updateRecorder.replaceDecorator(existingInjectDecorator.node, newDecoratorText, context.name); |
| } |
| else { |
| updateRecorder.addClassDecorator(node, newDecoratorText, context.name); |
| } |
| } |
| /** |
| * Migrates object literal providers which do not use "useValue", "useClass", |
| * "useExisting" or "useFactory". These providers behave differently in Ivy. e.g. |
| * |
| * ```ts |
| * {provide: X} -> {provide: X, useValue: undefined} // this is how it behaves in VE |
| * {provide: X} -> {provide: X, useClass: X} // this is how it behaves in Ivy |
| * ``` |
| * |
| * To ensure forward compatibility, we migrate these empty object literal providers |
| * to explicitly use `useValue: undefined`. |
| */ |
| _migrateLiteralProviders(literals) { |
| for (let { node, resolvedValue } of literals) { |
| if (this.visitedProviderLiterals.has(node)) { |
| continue; |
| } |
| this.visitedProviderLiterals.add(node); |
| if (!resolvedValue || !(resolvedValue instanceof Map) || !resolvedValue.has('provide') || |
| resolvedValue.has('useClass') || resolvedValue.has('useValue') || |
| resolvedValue.has('useExisting') || resolvedValue.has('useFactory')) { |
| continue; |
| } |
| const sourceFile = node.getSourceFile(); |
| const newObjectLiteral = ts.updateObjectLiteral(node, node.properties.concat(ts.createPropertyAssignment('useValue', ts.createIdentifier('undefined')))); |
| this.getUpdateRecorder(sourceFile) |
| .updateObjectLiteral(node, this.printer.printNode(ts.EmitHint.Unspecified, newObjectLiteral, sourceFile)); |
| } |
| } |
| /** |
| * Visits the given resolved value of a provider. Providers can be nested in |
| * arrays and we need to recursively walk through the providers to be able to |
| * migrate all referenced provider classes. e.g. "providers: [[A, [B]]]". |
| */ |
| _visitProviderResolvedValue(value, module) { |
| if (value instanceof imports_1.Reference && ts.isClassDeclaration(value.node)) { |
| this.migrateProviderClass(value.node, module); |
| } |
| else if (value instanceof Map) { |
| // If a "ClassProvider" has the "deps" property set, then we do not need to |
| // decorate the class. This is because the class is instantiated through the |
| // specified "deps" and the class does not need a factory definition. |
| if (value.has('provide') && value.has('useClass') && value.get('deps') == null) { |
| return this._visitProviderResolvedValue(value.get('useClass'), module); |
| } |
| } |
| else if (Array.isArray(value)) { |
| return value.reduce((res, v) => res.concat(this._visitProviderResolvedValue(v, module)), []); |
| } |
| else if (value instanceof partial_evaluator_1.DynamicValue) { |
| return [{ node: value.node, message: `Provider is not statically analyzable.` }]; |
| } |
| return []; |
| } |
| } |
| exports.MissingInjectableTransform = MissingInjectableTransform; |
| }); |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/missing-injectable/transform.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 {Reference} from '@angular/compiler-cli/src/ngtsc/imports';\nimport {DynamicValue, ResolvedValue} from '@angular/compiler-cli/src/ngtsc/partial_evaluator';\nimport {TypeScriptReflectionHost} from '@angular/compiler-cli/src/ngtsc/reflection';\nimport * as ts from 'typescript';\n\nimport {ImportManager} from '../../utils/import_manager';\nimport {getAngularDecorators} from '../../utils/ng_decorators';\n\nimport {ResolvedDirective, ResolvedNgModule} from './definition_collector';\nimport {ProviderLiteral, ProvidersEvaluator} from './providers_evaluator';\nimport {UpdateRecorder} from './update_recorder';\n\n/**\n * Name of decorators which imply that a given class does not need to be migrated.\n *    - `@Injectable`, `@Directive`, `@Component` and `@Pipe` instruct the compiler\n *       to generate a factory definition.\n *    - `@NgModule` instructs the compiler to generate a provider definition that holds\n *       the factory function.\n */\nconst NO_MIGRATE_DECORATORS = ['Injectable', 'Directive', 'Component', 'Pipe', 'NgModule'];\n\nexport interface AnalysisFailure {\n  node: ts.Node;\n  message: string;\n}\n\nexport class MissingInjectableTransform {\n  private printer = ts.createPrinter();\n  private importManager = new ImportManager(this.getUpdateRecorder, this.printer);\n  private providersEvaluator: ProvidersEvaluator;\n\n  /** Set of provider class declarations which were already checked or migrated. */\n  private visitedProviderClasses = new Set<ts.ClassDeclaration>();\n\n  /** Set of provider object literals which were already checked or migrated. */\n  private visitedProviderLiterals = new Set<ts.ObjectLiteralExpression>();\n\n  constructor(\n      private typeChecker: ts.TypeChecker,\n      private getUpdateRecorder: (sf: ts.SourceFile) => UpdateRecorder) {\n    this.providersEvaluator = new ProvidersEvaluator(\n        new TypeScriptReflectionHost(typeChecker), typeChecker, /* dependencyTracker */ null);\n  }\n\n  recordChanges() {\n    this.importManager.recordChanges();\n  }\n\n  /**\n   * Migrates all specified NgModule's by walking through referenced providers\n   * and decorating them with \"@Injectable\" if needed.\n   */\n  migrateModules(modules: ResolvedNgModule[]): AnalysisFailure[] {\n    return modules.reduce(\n        (failures, node) => failures.concat(this.migrateModule(node)), [] as AnalysisFailure[]);\n  }\n\n  /**\n   * Migrates all specified directives by walking through referenced providers\n   * and decorating them with \"@Injectable\" if needed.\n   */\n  migrateDirectives(directives: ResolvedDirective[]): AnalysisFailure[] {\n    return directives.reduce(\n        (failures, node) => failures.concat(this.migrateDirective(node)), [] as AnalysisFailure[]);\n  }\n\n  /** Migrates a given NgModule by walking through the referenced providers. */\n  migrateModule(module: ResolvedNgModule): AnalysisFailure[] {\n    if (module.providersExpr === null) {\n      return [];\n    }\n\n    const {resolvedValue, literals} = this.providersEvaluator.evaluate(module.providersExpr);\n    this._migrateLiteralProviders(literals);\n\n    if (!Array.isArray(resolvedValue)) {\n      return [\n        {node: module.providersExpr, message: 'Providers of module are not statically analyzable.'}\n      ];\n    }\n\n    return this._visitProviderResolvedValue(resolvedValue, module);\n  }\n\n\n  /**\n   * Migrates a given directive by walking through defined providers. This method\n   * also handles components with \"viewProviders\" defined.\n   */\n  migrateDirective(directive: ResolvedDirective): AnalysisFailure[] {\n    const failures: AnalysisFailure[] = [];\n\n    // Migrate \"providers\" on directives and components if defined.\n    if (directive.providersExpr) {\n      const {resolvedValue, literals} = this.providersEvaluator.evaluate(directive.providersExpr);\n      this._migrateLiteralProviders(literals);\n      if (!Array.isArray(resolvedValue)) {\n        return [\n          {node: directive.providersExpr, message: `Providers are not statically analyzable.`}\n        ];\n      }\n      failures.push(...this._visitProviderResolvedValue(resolvedValue, directive));\n    }\n\n    // Migrate \"viewProviders\" on components if defined.\n    if (directive.viewProvidersExpr) {\n      const {resolvedValue, literals} =\n          this.providersEvaluator.evaluate(directive.viewProvidersExpr);\n      this._migrateLiteralProviders(literals);\n      if (!Array.isArray(resolvedValue)) {\n        return [\n          {node: directive.viewProvidersExpr, message: `Providers are not statically analyzable.`}\n        ];\n      }\n      failures.push(...this._visitProviderResolvedValue(resolvedValue, directive));\n    }\n    return failures;\n  }\n\n  /**\n   * Migrates a given provider class if it is not decorated with\n   * any Angular decorator.\n   */\n  migrateProviderClass(node: ts.ClassDeclaration, context: ResolvedNgModule|ResolvedDirective) {\n    if (this.visitedProviderClasses.has(node)) {\n      return;\n    }\n    this.visitedProviderClasses.add(node);\n\n    const sourceFile = node.getSourceFile();\n\n    // We cannot migrate provider classes outside of source files. This is because the\n    // migration for third-party library files should happen in \"ngcc\", and in general\n    // would also involve metadata parsing.\n    if (sourceFile.isDeclarationFile) {\n      return;\n    }\n\n    const ngDecorators =\n        node.decorators ? getAngularDecorators(this.typeChecker, node.decorators) : null;\n\n    if (ngDecorators !== null &&\n        ngDecorators.some(d => NO_MIGRATE_DECORATORS.indexOf(d.name) !== -1)) {\n      return;\n    }\n\n    const updateRecorder = this.getUpdateRecorder(sourceFile);\n    const importExpr =\n        this.importManager.addImportToSourceFile(sourceFile, 'Injectable', '@angular/core');\n    const newDecoratorExpr = ts.createDecorator(ts.createCall(importExpr, undefined, undefined));\n    const newDecoratorText =\n        this.printer.printNode(ts.EmitHint.Unspecified, newDecoratorExpr, sourceFile);\n\n\n    // In case the class is already decorated with \"@Inject(..)\", we replace the \"@Inject\"\n    // decorator with \"@Injectable()\" since using \"@Inject(..)\" on a class is a noop and\n    // most likely was meant to be \"@Injectable()\".\n    const existingInjectDecorator =\n        ngDecorators !== null ? ngDecorators.find(d => d.name === 'Inject') : null;\n    if (existingInjectDecorator) {\n      updateRecorder.replaceDecorator(existingInjectDecorator.node, newDecoratorText, context.name);\n    } else {\n      updateRecorder.addClassDecorator(node, newDecoratorText, context.name);\n    }\n  }\n\n  /**\n   * Migrates object literal providers which do not use \"useValue\", \"useClass\",\n   * \"useExisting\" or \"useFactory\". These providers behave differently in Ivy. e.g.\n   *\n   * ```ts\n   *   {provide: X} -> {provide: X, useValue: undefined} // this is how it behaves in VE\n   *   {provide: X} -> {provide: X, useClass: X} // this is how it behaves in Ivy\n   * ```\n   *\n   * To ensure forward compatibility, we migrate these empty object literal providers\n   * to explicitly use `useValue: undefined`.\n   */\n  private _migrateLiteralProviders(literals: ProviderLiteral[]) {\n    for (let {node, resolvedValue} of literals) {\n      if (this.visitedProviderLiterals.has(node)) {\n        continue;\n      }\n      this.visitedProviderLiterals.add(node);\n\n      if (!resolvedValue || !(resolvedValue instanceof Map) || !resolvedValue.has('provide') ||\n          resolvedValue.has('useClass') || resolvedValue.has('useValue') ||\n          resolvedValue.has('useExisting') || resolvedValue.has('useFactory')) {\n        continue;\n      }\n\n      const sourceFile = node.getSourceFile();\n      const newObjectLiteral = ts.updateObjectLiteral(\n          node,\n          node.properties.concat(\n              ts.createPropertyAssignment('useValue', ts.createIdentifier('undefined'))));\n\n      this.getUpdateRecorder(sourceFile)\n          .updateObjectLiteral(\n              node, this.printer.printNode(ts.EmitHint.Unspecified, newObjectLiteral, sourceFile));\n    }\n  }\n\n  /**\n   * Visits the given resolved value of a provider. Providers can be nested in\n   * arrays and we need to recursively walk through the providers to be able to\n   * migrate all referenced provider classes. e.g. \"providers: [[A, [B]]]\".\n   */\n  private _visitProviderResolvedValue(value: ResolvedValue, module: ResolvedNgModule):\n      AnalysisFailure[] {\n    if (value instanceof Reference && ts.isClassDeclaration(value.node)) {\n      this.migrateProviderClass(value.node, module);\n    } else if (value instanceof Map) {\n      // If a \"ClassProvider\" has the \"deps\" property set, then we do not need to\n      // decorate the class. This is because the class is instantiated through the\n      // specified \"deps\" and the class does not need a factory definition.\n      if (value.has('provide') && value.has('useClass') && value.get('deps') == null) {\n        return this._visitProviderResolvedValue(value.get('useClass')!, module);\n      }\n    } else if (Array.isArray(value)) {\n      return value.reduce(\n          (res, v) => res.concat(this._visitProviderResolvedValue(v, module)),\n          [] as AnalysisFailure[]);\n    } else if (value instanceof DynamicValue) {\n      return [{node: value.node, message: `Provider is not statically analyzable.`}];\n    }\n    return [];\n  }\n}\n"]} |
