@angular/core
Version:
Angular - the core framework
369 lines • 65.1 kB
JavaScript
/**
* @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 __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
(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/undecorated-classes-with-di/transform", ["require", "exports", "@angular/core", "typescript", "@angular/core/schematics/utils/import_manager", "@angular/core/schematics/utils/ng_decorators", "@angular/core/schematics/utils/typescript/class_declaration", "@angular/core/schematics/utils/typescript/find_base_classes", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/migrations/undecorated-classes-with-di/decorator_rewrite/convert_directive_metadata", "@angular/core/schematics/migrations/undecorated-classes-with-di/decorator_rewrite/decorator_rewriter", "@angular/core/schematics/migrations/undecorated-classes-with-di/ng_declaration_collector"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("@angular/core");
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 class_declaration_1 = require("@angular/core/schematics/utils/typescript/class_declaration");
const find_base_classes_1 = require("@angular/core/schematics/utils/typescript/find_base_classes");
const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
const convert_directive_metadata_1 = require("@angular/core/schematics/migrations/undecorated-classes-with-di/decorator_rewrite/convert_directive_metadata");
const decorator_rewriter_1 = require("@angular/core/schematics/migrations/undecorated-classes-with-di/decorator_rewrite/decorator_rewriter");
const ng_declaration_collector_1 = require("@angular/core/schematics/migrations/undecorated-classes-with-di/ng_declaration_collector");
class UndecoratedClassesTransform {
constructor(typeChecker, compiler, evaluator, getUpdateRecorder) {
this.typeChecker = typeChecker;
this.compiler = compiler;
this.evaluator = evaluator;
this.getUpdateRecorder = getUpdateRecorder;
this.printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
this.importManager = new import_manager_1.ImportManager(this.getUpdateRecorder, this.printer);
this.decoratorRewriter = new decorator_rewriter_1.DecoratorRewriter(this.importManager, this.typeChecker, this.evaluator, this.compiler);
/** Set of class declarations which have been decorated with "@Directive". */
this.decoratedDirectives = new Set();
/** Set of class declarations which have been decorated with "@Injectable" */
this.decoratedProviders = new Set();
/**
* Set of class declarations which have been analyzed and need to specify
* an explicit constructor.
*/
this.missingExplicitConstructorClasses = new Set();
this.symbolResolver = compiler['_symbolResolver'];
this.compilerHost = compiler['_host'];
this.metadataResolver = compiler['_metadataResolver'];
// Unset the default error recorder so that the reflector will throw an exception
// if metadata cannot be resolved.
this.compiler.reflector['errorRecorder'] = undefined;
// Disables that static symbols are resolved through summaries from within the static
// reflector. Summaries cannot be used for decorator serialization as decorators are
// omitted in summaries and the decorator can't be reconstructed from the directive summary.
this._disableSummaryResolution();
}
/**
* Migrates decorated directives which can potentially inherit a constructor
* from an undecorated base class. All base classes until the first one
* with an explicit constructor will be decorated with the abstract "@Directive()"
* decorator. See case 1 in the migration plan: https://hackmd.io/@alx/S1XKqMZeS
*/
migrateDecoratedDirectives(directives) {
return directives.reduce((failures, node) => failures.concat(this._migrateDirectiveBaseClass(node)), []);
}
/**
* Migrates decorated providers which can potentially inherit a constructor
* from an undecorated base class. All base classes until the first one
* with an explicit constructor will be decorated with the "@Injectable()".
*/
migrateDecoratedProviders(providers) {
return providers.reduce((failures, node) => failures.concat(this._migrateProviderBaseClass(node)), []);
}
_migrateProviderBaseClass(node) {
return this._migrateDecoratedClassWithInheritedCtor(node, symbol => this.metadataResolver.isInjectable(symbol), node => this._addInjectableDecorator(node));
}
_migrateDirectiveBaseClass(node) {
return this._migrateDecoratedClassWithInheritedCtor(node, symbol => this.metadataResolver.isDirective(symbol), node => this._addAbstractDirectiveDecorator(node));
}
_migrateDecoratedClassWithInheritedCtor(node, isClassDecorated, addClassDecorator) {
// In case the provider has an explicit constructor, we don't need to do anything
// because the class is already decorated and does not inherit a constructor.
if (class_declaration_1.hasExplicitConstructor(node)) {
return [];
}
const orderedBaseClasses = find_base_classes_1.findBaseClassDeclarations(node, this.typeChecker);
const undecoratedBaseClasses = [];
for (let { node: baseClass, identifier } of orderedBaseClasses) {
const baseClassFile = baseClass.getSourceFile();
if (class_declaration_1.hasExplicitConstructor(baseClass)) {
// All classes in between the decorated class and the undecorated class
// that defines the constructor need to be decorated as well.
undecoratedBaseClasses.forEach(b => addClassDecorator(b));
if (baseClassFile.isDeclarationFile) {
const staticSymbol = this._getStaticSymbolOfIdentifier(identifier);
// If the base class is decorated through metadata files, we don't
// need to add a comment to the derived class for the external base class.
if (staticSymbol && isClassDecorated(staticSymbol)) {
break;
}
// Find the last class in the inheritance chain that is decorated and will be
// used as anchor for a comment explaining that the class that defines the
// constructor cannot be decorated automatically.
const lastDecoratedClass = undecoratedBaseClasses[undecoratedBaseClasses.length - 1] || node;
return this._addMissingExplicitConstructorTodo(lastDecoratedClass);
}
// Decorate the class that defines the constructor that is inherited.
addClassDecorator(baseClass);
break;
}
// Add the class decorator for all base classes in the inheritance chain until
// the base class with the explicit constructor. The decorator will be only
// added for base classes which can be modified.
if (!baseClassFile.isDeclarationFile) {
undecoratedBaseClasses.push(baseClass);
}
}
return [];
}
/**
* Adds the abstract "@Directive()" decorator to the given class in case there
* is no existing directive decorator.
*/
_addAbstractDirectiveDecorator(baseClass) {
if (ng_declaration_collector_1.hasDirectiveDecorator(baseClass, this.typeChecker) ||
this.decoratedDirectives.has(baseClass)) {
return;
}
const baseClassFile = baseClass.getSourceFile();
const recorder = this.getUpdateRecorder(baseClassFile);
const directiveExpr = this.importManager.addImportToSourceFile(baseClassFile, 'Directive', '@angular/core');
const newDecorator = ts.createDecorator(ts.createCall(directiveExpr, undefined, []));
const newDecoratorText = this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, baseClassFile);
recorder.addClassDecorator(baseClass, newDecoratorText);
this.decoratedDirectives.add(baseClass);
}
/**
* Adds the abstract "@Injectable()" decorator to the given class in case there
* is no existing directive decorator.
*/
_addInjectableDecorator(baseClass) {
if (ng_declaration_collector_1.hasInjectableDecorator(baseClass, this.typeChecker) ||
this.decoratedProviders.has(baseClass)) {
return;
}
const baseClassFile = baseClass.getSourceFile();
const recorder = this.getUpdateRecorder(baseClassFile);
const injectableExpr = this.importManager.addImportToSourceFile(baseClassFile, 'Injectable', '@angular/core');
const newDecorator = ts.createDecorator(ts.createCall(injectableExpr, undefined, []));
const newDecoratorText = this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, baseClassFile);
recorder.addClassDecorator(baseClass, newDecoratorText);
this.decoratedProviders.add(baseClass);
}
/** Adds a comment for adding an explicit constructor to the given class declaration. */
_addMissingExplicitConstructorTodo(node) {
// In case a todo comment has been already inserted to the given class, we don't
// want to add a comment or transform failure multiple times.
if (this.missingExplicitConstructorClasses.has(node)) {
return [];
}
this.missingExplicitConstructorClasses.add(node);
const recorder = this.getUpdateRecorder(node.getSourceFile());
recorder.addClassComment(node, 'TODO: add explicit constructor');
return [{ node: node, message: 'Class needs to declare an explicit constructor.' }];
}
/**
* Migrates undecorated directives which were referenced in NgModule declarations.
* These directives inherit the metadata from a parent base class, but with Ivy
* these classes need to explicitly have a decorator for locality. The migration
* determines the inherited decorator and copies it to the undecorated declaration.
*
* Note that the migration serializes the metadata for external declarations
* where the decorator is not part of the source file AST.
*
* See case 2 in the migration plan: https://hackmd.io/@alx/S1XKqMZeS
*/
migrateUndecoratedDeclarations(directives) {
return directives.reduce((failures, node) => failures.concat(this._migrateDerivedDeclaration(node)), []);
}
_migrateDerivedDeclaration(node) {
const targetSourceFile = node.getSourceFile();
const orderedBaseClasses = find_base_classes_1.findBaseClassDeclarations(node, this.typeChecker);
let newDecoratorText = null;
for (let { node: baseClass, identifier } of orderedBaseClasses) {
// Before looking for decorators within the metadata or summary files, we
// try to determine the directive decorator through the source file AST.
if (baseClass.decorators) {
const ngDecorator = ng_decorators_1.getAngularDecorators(this.typeChecker, baseClass.decorators)
.find(({ name }) => name === 'Component' || name === 'Directive' || name === 'Pipe');
if (ngDecorator) {
const newDecorator = this.decoratorRewriter.rewrite(ngDecorator, node.getSourceFile());
newDecoratorText = this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, ngDecorator.node.getSourceFile());
break;
}
}
// If no metadata could be found within the source-file AST, try to find
// decorator data through Angular metadata and summary files.
const staticSymbol = this._getStaticSymbolOfIdentifier(identifier);
// Check if the static symbol resolves to a class declaration with
// pipe or directive metadata.
if (!staticSymbol ||
!(this.metadataResolver.isPipe(staticSymbol) ||
this.metadataResolver.isDirective(staticSymbol))) {
continue;
}
const metadata = this._resolveDeclarationMetadata(staticSymbol);
// If no metadata could be resolved for the static symbol, print a failure message
// and ask the developer to manually migrate the class. This case is rare because
// usually decorator metadata is always present but just can't be read if a program
// only has access to summaries (this is a special case in google3).
if (!metadata) {
return [{
node,
message: `Class cannot be migrated as the inherited metadata from ` +
`${identifier.getText()} cannot be converted into a decorator. Please manually
decorate the class.`,
}];
}
const newDecorator = this._constructDecoratorFromMetadata(metadata, targetSourceFile);
if (!newDecorator) {
const annotationType = metadata.type;
return [{
node,
message: `Class cannot be migrated as the inherited @${annotationType} decorator ` +
`cannot be copied. Please manually add a @${annotationType} decorator.`,
}];
}
// In case the decorator could be constructed from the resolved metadata, use
// that decorator for the derived undecorated classes.
newDecoratorText =
this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, targetSourceFile);
break;
}
if (!newDecoratorText) {
return [{
node,
message: 'Class cannot be migrated as no directive/component/pipe metadata could be found. ' +
'Please manually add a @Directive, @Component or @Pipe decorator.'
}];
}
this.getUpdateRecorder(targetSourceFile).addClassDecorator(node, newDecoratorText);
return [];
}
/** Records all changes that were made in the import manager. */
recordChanges() {
this.importManager.recordChanges();
}
/**
* Constructs a TypeScript decorator node from the specified declaration metadata. Returns
* null if the metadata could not be simplified/resolved.
*/
_constructDecoratorFromMetadata(directiveMetadata, targetSourceFile) {
try {
const decoratorExpr = convert_directive_metadata_1.convertDirectiveMetadataToExpression(directiveMetadata.metadata, staticSymbol => this.compilerHost
.fileNameToModuleName(staticSymbol.filePath, targetSourceFile.fileName)
.replace(/\/index$/, ''), (moduleName, name) => this.importManager.addImportToSourceFile(targetSourceFile, name, moduleName), (propertyName, value) => {
// Only normalize properties called "changeDetection" and "encapsulation"
// for "@Directive" and "@Component" annotations.
if (directiveMetadata.type === 'Pipe') {
return null;
}
// Instead of using the number as value for the "changeDetection" and
// "encapsulation" properties, we want to use the actual enum symbols.
if (propertyName === 'changeDetection' && typeof value === 'number') {
return ts.createPropertyAccess(this.importManager.addImportToSourceFile(targetSourceFile, 'ChangeDetectionStrategy', '@angular/core'), core_1.ChangeDetectionStrategy[value]);
}
else if (propertyName === 'encapsulation' && typeof value === 'number') {
return ts.createPropertyAccess(this.importManager.addImportToSourceFile(targetSourceFile, 'ViewEncapsulation', '@angular/core'), core_1.ViewEncapsulation[value]);
}
return null;
});
return ts.createDecorator(ts.createCall(this.importManager.addImportToSourceFile(targetSourceFile, directiveMetadata.type, '@angular/core'), undefined, [decoratorExpr]));
}
catch (e) {
if (e instanceof convert_directive_metadata_1.UnexpectedMetadataValueError) {
return null;
}
throw e;
}
}
/**
* Resolves the declaration metadata of a given static symbol. The metadata
* is determined by resolving metadata for the static symbol.
*/
_resolveDeclarationMetadata(symbol) {
try {
// Note that this call can throw if the metadata is not computable. In that
// case we are not able to serialize the metadata into a decorator and we return
// null.
const annotations = this.compiler.reflector.annotations(symbol).find(s => s.ngMetadataName === 'Component' || s.ngMetadataName === 'Directive' ||
s.ngMetadataName === 'Pipe');
if (!annotations) {
return null;
}
const { ngMetadataName } = annotations, metadata = __rest(annotations, ["ngMetadataName"]);
// Delete the "ngMetadataName" property as we don't want to generate
// a property assignment in the new decorator for that internal property.
delete metadata['ngMetadataName'];
return { type: ngMetadataName, metadata };
}
catch (e) {
return null;
}
}
_getStaticSymbolOfIdentifier(node) {
const sourceFile = node.getSourceFile();
const resolvedImport = imports_1.getImportOfIdentifier(this.typeChecker, node);
if (!resolvedImport) {
return null;
}
const moduleName = this.compilerHost.moduleNameToFileName(resolvedImport.importModule, sourceFile.fileName);
if (!moduleName) {
return null;
}
// Find the declaration symbol as symbols could be aliased due to
// metadata re-exports.
return this.compiler.reflector.findSymbolDeclaration(this.symbolResolver.getStaticSymbol(moduleName, resolvedImport.name));
}
/**
* Disables that static symbols are resolved through summaries. Summaries
* cannot be used for decorator analysis as decorators are omitted in summaries.
*/
_disableSummaryResolution() {
// We never want to resolve symbols through summaries. Summaries never contain
// decorators for class symbols and therefore summaries will cause every class
// to be considered as undecorated. See reason for this in: "ToJsonSerializer".
// In order to ensure that metadata is not retrieved through summaries, we
// need to disable summary resolution, clear previous symbol caches. This way
// future calls to "StaticReflector#annotations" are based on metadata files.
this.symbolResolver['_resolveSymbolFromSummary'] = () => null;
this.symbolResolver['resolvedSymbols'].clear();
this.symbolResolver['symbolFromFile'].clear();
this.compiler.reflector['annotationCache'].clear();
// Original summary resolver used by the AOT compiler.
const summaryResolver = this.symbolResolver['summaryResolver'];
// Additionally we need to ensure that no files are treated as "library" files when
// resolving metadata. This is necessary because by default the symbol resolver discards
// class metadata for library files. See "StaticSymbolResolver#createResolvedSymbol".
// Patching this function **only** for the static symbol resolver ensures that metadata
// is not incorrectly omitted. Note that we only want to do this for the symbol resolver
// because otherwise we could break the summary loading logic which is used to detect
// if a static symbol is either a directive, component or pipe (see MetadataResolver).
this.symbolResolver['summaryResolver'] = {
fromSummaryFileName: summaryResolver.fromSummaryFileName.bind(summaryResolver),
addSummary: summaryResolver.addSummary.bind(summaryResolver),
getImportAs: summaryResolver.getImportAs.bind(summaryResolver),
getKnownModuleName: summaryResolver.getKnownModuleName.bind(summaryResolver),
resolveSummary: summaryResolver.resolveSummary.bind(summaryResolver),
toSummaryFileName: summaryResolver.toSummaryFileName.bind(summaryResolver),
getSymbolsOf: summaryResolver.getSymbolsOf.bind(summaryResolver),
isLibraryFile: () => false,
};
}
}
exports.UndecoratedClassesTransform = UndecoratedClassesTransform;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/undecorated-classes-with-di/transform.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 {AotCompiler, AotCompilerHost, CompileMetadataResolver, StaticSymbol, StaticSymbolResolver, SummaryResolver} from '@angular/compiler';\nimport {PartialEvaluator} from '@angular/compiler-cli/src/ngtsc/partial_evaluator';\nimport {ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';\nimport * as ts from 'typescript';\n\nimport {ImportManager} from '../../utils/import_manager';\nimport {getAngularDecorators} from '../../utils/ng_decorators';\nimport {hasExplicitConstructor} from '../../utils/typescript/class_declaration';\nimport {findBaseClassDeclarations} from '../../utils/typescript/find_base_classes';\nimport {getImportOfIdentifier} from '../../utils/typescript/imports';\n\nimport {convertDirectiveMetadataToExpression, UnexpectedMetadataValueError} from './decorator_rewrite/convert_directive_metadata';\nimport {DecoratorRewriter} from './decorator_rewrite/decorator_rewriter';\nimport {hasDirectiveDecorator, hasInjectableDecorator} from './ng_declaration_collector';\nimport {UpdateRecorder} from './update_recorder';\n\n\n\n/** Resolved metadata of a declaration. */\ninterface DeclarationMetadata {\n  metadata: any;\n  type: 'Component'|'Directive'|'Pipe';\n}\n\nexport interface TransformFailure {\n  node: ts.Node;\n  message: string;\n}\n\nexport class UndecoratedClassesTransform {\n  private printer = ts.createPrinter({newLine: ts.NewLineKind.LineFeed});\n  private importManager = new ImportManager(this.getUpdateRecorder, this.printer);\n  private decoratorRewriter =\n      new DecoratorRewriter(this.importManager, this.typeChecker, this.evaluator, this.compiler);\n\n  private compilerHost: AotCompilerHost;\n  private symbolResolver: StaticSymbolResolver;\n  private metadataResolver: CompileMetadataResolver;\n\n  /** Set of class declarations which have been decorated with \"@Directive\". */\n  private decoratedDirectives = new Set<ts.ClassDeclaration>();\n  /** Set of class declarations which have been decorated with \"@Injectable\" */\n  private decoratedProviders = new Set<ts.ClassDeclaration>();\n  /**\n   * Set of class declarations which have been analyzed and need to specify\n   * an explicit constructor.\n   */\n  private missingExplicitConstructorClasses = new Set<ts.ClassDeclaration>();\n\n  constructor(\n      private typeChecker: ts.TypeChecker, private compiler: AotCompiler,\n      private evaluator: PartialEvaluator,\n      private getUpdateRecorder: (sf: ts.SourceFile) => UpdateRecorder) {\n    this.symbolResolver = compiler['_symbolResolver'];\n    this.compilerHost = compiler['_host'];\n    this.metadataResolver = compiler['_metadataResolver'];\n\n    // Unset the default error recorder so that the reflector will throw an exception\n    // if metadata cannot be resolved.\n    this.compiler.reflector['errorRecorder'] = undefined;\n\n    // Disables that static symbols are resolved through summaries from within the static\n    // reflector. Summaries cannot be used for decorator serialization as decorators are\n    // omitted in summaries and the decorator can't be reconstructed from the directive summary.\n    this._disableSummaryResolution();\n  }\n\n  /**\n   * Migrates decorated directives which can potentially inherit a constructor\n   * from an undecorated base class. All base classes until the first one\n   * with an explicit constructor will be decorated with the abstract \"@Directive()\"\n   * decorator. See case 1 in the migration plan: https://hackmd.io/@alx/S1XKqMZeS\n   */\n  migrateDecoratedDirectives(directives: ts.ClassDeclaration[]): TransformFailure[] {\n    return directives.reduce(\n        (failures, node) => failures.concat(this._migrateDirectiveBaseClass(node)),\n        [] as TransformFailure[]);\n  }\n\n  /**\n   * Migrates decorated providers which can potentially inherit a constructor\n   * from an undecorated base class. All base classes until the first one\n   * with an explicit constructor will be decorated with the \"@Injectable()\".\n   */\n  migrateDecoratedProviders(providers: ts.ClassDeclaration[]): TransformFailure[] {\n    return providers.reduce(\n        (failures, node) => failures.concat(this._migrateProviderBaseClass(node)),\n        [] as TransformFailure[]);\n  }\n\n  private _migrateProviderBaseClass(node: ts.ClassDeclaration): TransformFailure[] {\n    return this._migrateDecoratedClassWithInheritedCtor(\n        node, symbol => this.metadataResolver.isInjectable(symbol),\n        node => this._addInjectableDecorator(node));\n  }\n\n  private _migrateDirectiveBaseClass(node: ts.ClassDeclaration): TransformFailure[] {\n    return this._migrateDecoratedClassWithInheritedCtor(\n        node, symbol => this.metadataResolver.isDirective(symbol),\n        node => this._addAbstractDirectiveDecorator(node));\n  }\n\n\n  private _migrateDecoratedClassWithInheritedCtor(\n      node: ts.ClassDeclaration, isClassDecorated: (symbol: StaticSymbol) => boolean,\n      addClassDecorator: (node: ts.ClassDeclaration) => void): TransformFailure[] {\n    // In case the provider has an explicit constructor, we don't need to do anything\n    // because the class is already decorated and does not inherit a constructor.\n    if (hasExplicitConstructor(node)) {\n      return [];\n    }\n\n    const orderedBaseClasses = findBaseClassDeclarations(node, this.typeChecker);\n    const undecoratedBaseClasses: ts.ClassDeclaration[] = [];\n\n    for (let {node: baseClass, identifier} of orderedBaseClasses) {\n      const baseClassFile = baseClass.getSourceFile();\n\n      if (hasExplicitConstructor(baseClass)) {\n        // All classes in between the decorated class and the undecorated class\n        // that defines the constructor need to be decorated as well.\n        undecoratedBaseClasses.forEach(b => addClassDecorator(b));\n\n        if (baseClassFile.isDeclarationFile) {\n          const staticSymbol = this._getStaticSymbolOfIdentifier(identifier);\n\n          // If the base class is decorated through metadata files, we don't\n          // need to add a comment to the derived class for the external base class.\n          if (staticSymbol && isClassDecorated(staticSymbol)) {\n            break;\n          }\n\n          // Find the last class in the inheritance chain that is decorated and will be\n          // used as anchor for a comment explaining that the class that defines the\n          // constructor cannot be decorated automatically.\n          const lastDecoratedClass =\n              undecoratedBaseClasses[undecoratedBaseClasses.length - 1] || node;\n          return this._addMissingExplicitConstructorTodo(lastDecoratedClass);\n        }\n\n        // Decorate the class that defines the constructor that is inherited.\n        addClassDecorator(baseClass);\n        break;\n      }\n\n      // Add the class decorator for all base classes in the inheritance chain until\n      // the base class with the explicit constructor. The decorator will be only\n      // added for base classes which can be modified.\n      if (!baseClassFile.isDeclarationFile) {\n        undecoratedBaseClasses.push(baseClass);\n      }\n    }\n    return [];\n  }\n\n  /**\n   * Adds the abstract \"@Directive()\" decorator to the given class in case there\n   * is no existing directive decorator.\n   */\n  private _addAbstractDirectiveDecorator(baseClass: ts.ClassDeclaration) {\n    if (hasDirectiveDecorator(baseClass, this.typeChecker) ||\n        this.decoratedDirectives.has(baseClass)) {\n      return;\n    }\n\n    const baseClassFile = baseClass.getSourceFile();\n    const recorder = this.getUpdateRecorder(baseClassFile);\n    const directiveExpr =\n        this.importManager.addImportToSourceFile(baseClassFile, 'Directive', '@angular/core');\n\n    const newDecorator = ts.createDecorator(ts.createCall(directiveExpr, undefined, []));\n    const newDecoratorText =\n        this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, baseClassFile);\n\n    recorder.addClassDecorator(baseClass, newDecoratorText);\n    this.decoratedDirectives.add(baseClass);\n  }\n\n  /**\n   * Adds the abstract \"@Injectable()\" decorator to the given class in case there\n   * is no existing directive decorator.\n   */\n  private _addInjectableDecorator(baseClass: ts.ClassDeclaration) {\n    if (hasInjectableDecorator(baseClass, this.typeChecker) ||\n        this.decoratedProviders.has(baseClass)) {\n      return;\n    }\n\n    const baseClassFile = baseClass.getSourceFile();\n    const recorder = this.getUpdateRecorder(baseClassFile);\n    const injectableExpr =\n        this.importManager.addImportToSourceFile(baseClassFile, 'Injectable', '@angular/core');\n\n    const newDecorator = ts.createDecorator(ts.createCall(injectableExpr, undefined, []));\n    const newDecoratorText =\n        this.printer.printNode(ts.EmitHint.Unspecified, newDecorator, baseClassFile);\n\n    recorder.addClassDecorator(baseClass, newDecoratorText);\n    this.decoratedProviders.add(baseClass);\n  }\n\n  /** Adds a comment for adding an explicit constructor to the given class declaration. */\n  private _addMissingExplicitConstructorTodo(node: ts.ClassDeclaration): TransformFailure[] {\n    // In case a to