All ngcc migrations

packages/compiler-cli/ngcc/src/analysis/decoration_analyzer.ts

@@ -7,6 +7,7 @@
  */
 import {ConstantPool} from '@angular/compiler';
 import * as ts from 'typescript';
+
 import {BaseDefDecoratorHandler, ComponentDecoratorHandler, DirectiveDecoratorHandler, InjectableDecoratorHandler, NgModuleDecoratorHandler, PipeDecoratorHandler, ReferencesRegistry, ResourceLoader} from '../../../src/ngtsc/annotations';
 import {CycleAnalyzer, ImportGraph} from '../../../src/ngtsc/cycles';
 import {isFatalDiagnosticError} from '../../../src/ngtsc/diagnostics';
@@ -18,13 +19,18 @@ import {ClassDeclaration} from '../../../src/ngtsc/reflection';
 import {LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../../src/ngtsc/scope';
 import {CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence} from '../../../src/ngtsc/transform';
 import {NgccClassSymbol, NgccReflectionHost} from '../host/ngcc_host';
-import {Migration, MigrationHost} from '../migrations/migration';
+import {Migration} from '../migrations/migration';
+import {MissingInjectableMigration} from '../migrations/missing_injectable_migration';
+import {UndecoratedChildMigration} from '../migrations/undecorated_child_migration';
+import {UndecoratedParentMigration} from '../migrations/undecorated_parent_migration';
 import {EntryPointBundle} from '../packages/entry_point_bundle';
 import {isDefined} from '../utils';
+
 import {DefaultMigrationHost} from './migration_host';
 import {AnalyzedClass, AnalyzedFile, CompiledClass, CompiledFile, DecorationAnalyses} from './types';
 import {analyzeDecorators, isWithinPackage} from './util';
 
+
 /**
  * Simple class that resolves and loads files directly from the filesystem.
  */
@@ -100,7 +106,11 @@ export class DecorationAnalyzer {
         this.reflectionHost, this.evaluator, this.metaRegistry, NOOP_DEFAULT_IMPORT_RECORDER,
         this.isCore),
   ];
-  migrations: Migration[] = [];
+  migrations: Migration[] = [
+    new UndecoratedParentMigration(),
+    new UndecoratedChildMigration(),
+    new MissingInjectableMigration(),
+  ];
 
   constructor(
       private fs: FileSystem, private bundle: EntryPointBundle,
@@ -118,9 +128,9 @@ export class DecorationAnalyzer {
                               .filter(sourceFile => isWithinPackage(this.packagePath, sourceFile))
                               .map(sourceFile => this.analyzeFile(sourceFile))
                               .filter(isDefined);
-    const migrationHost = new DefaultMigrationHost(
-        this.reflectionHost, this.fullMetaReader, this.evaluator, this.handlers, analyzedFiles);
-    analyzedFiles.forEach(analyzedFile => this.migrateFile(migrationHost, analyzedFile));
+
+    this.applyMigrations(analyzedFiles);
+
     analyzedFiles.forEach(analyzedFile => this.resolveFile(analyzedFile));
     const compiledFiles = analyzedFiles.map(analyzedFile => this.compileFile(analyzedFile));
     compiledFiles.forEach(
@@ -146,21 +156,27 @@ export class DecorationAnalyzer {
     return analyzedClass;
   }
 
-  protected migrateFile(migrationHost: MigrationHost, analyzedFile: AnalyzedFile): void {
-    analyzedFile.analyzedClasses.forEach(({declaration}) => {
-      this.migrations.forEach(migration => {
-        try {
-          const result = migration.apply(declaration, migrationHost);
-          if (result !== null) {
-            this.diagnosticHandler(result);
-          }
-        } catch (e) {
-          if (isFatalDiagnosticError(e)) {
-            this.diagnosticHandler(e.toDiagnostic());
-          } else {
-            throw e;
+  protected applyMigrations(analyzedFiles: AnalyzedFile[]): void {
+    const migrationHost = new DefaultMigrationHost(
+        this.reflectionHost, this.fullMetaReader, this.evaluator, this.handlers,
+        this.bundle.entryPoint.path, analyzedFiles);
+
+    this.migrations.forEach(migration => {
+      analyzedFiles.forEach(analyzedFile => {
+        analyzedFile.analyzedClasses.forEach(({declaration}) => {
+          try {
+            const result = migration.apply(declaration, migrationHost);
+            if (result !== null) {
+              this.diagnosticHandler(result);
+            }
+          } catch (e) {
+            if (isFatalDiagnosticError(e)) {
+              this.diagnosticHandler(e.toDiagnostic());
+            } else {
+              throw e;
+            }
           }
-        }
+        });
       });
     });
   }

packages/compiler-cli/ngcc/src/analysis/migration_host.ts

@@ -6,15 +6,18 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as ts from 'typescript';
+
 import {ErrorCode, FatalDiagnosticError} from '../../../src/ngtsc/diagnostics';
+import {AbsoluteFsPath} from '../../../src/ngtsc/file_system';
 import {MetadataReader} from '../../../src/ngtsc/metadata';
 import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
 import {ClassDeclaration, Decorator} from '../../../src/ngtsc/reflection';
-import {DecoratorHandler} from '../../../src/ngtsc/transform';
+import {DecoratorHandler, HandlerFlags} from '../../../src/ngtsc/transform';
 import {NgccReflectionHost} from '../host/ngcc_host';
 import {MigrationHost} from '../migrations/migration';
+
 import {AnalyzedClass, AnalyzedFile} from './types';
-import {analyzeDecorators} from './util';
+import {analyzeDecorators, isWithinPackage} from './util';
 
 /**
  * The standard implementation of `MigrationHost`, which is created by the
@@ -24,11 +27,12 @@ export class DefaultMigrationHost implements MigrationHost {
   constructor(
       readonly reflectionHost: NgccReflectionHost, readonly metadata: MetadataReader,
       readonly evaluator: PartialEvaluator, private handlers: DecoratorHandler<any, any>[],
-      private analyzedFiles: AnalyzedFile[]) {}
+      private entryPointPath: AbsoluteFsPath, private analyzedFiles: AnalyzedFile[]) {}
 
-  injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator): void {
+  injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator, flags?: HandlerFlags):
+      void {
     const classSymbol = this.reflectionHost.getClassSymbol(clazz) !;
-    const newAnalyzedClass = analyzeDecorators(classSymbol, [decorator], this.handlers);
+    const newAnalyzedClass = analyzeDecorators(classSymbol, [decorator], this.handlers, flags);
     if (newAnalyzedClass === null) {
       return;
     }
@@ -41,6 +45,25 @@ export class DefaultMigrationHost implements MigrationHost {
       mergeAnalyzedClasses(oldAnalyzedClass, newAnalyzedClass);
     }
   }
+
+  getAllDecorators(clazz: ClassDeclaration): Decorator[]|null {
+    const sourceFile = clazz.getSourceFile();
+    const analyzedFile = this.analyzedFiles.find(file => file.sourceFile === sourceFile);
+    if (analyzedFile === undefined) {
+      return null;
+    }
+
+    const analyzedClass = analyzedFile.analyzedClasses.find(c => c.declaration === clazz);
+    if (analyzedClass === undefined) {
+      return null;
+    }
+
+    return analyzedClass.decorators;
+  }
+
+  isInScope(clazz: ClassDeclaration): boolean {
+    return isWithinPackage(this.entryPointPath, clazz.getSourceFile());
+  }
 }
 
 function getOrCreateAnalyzedFile(

packages/compiler-cli/ngcc/src/analysis/util.ts

@@ -10,7 +10,7 @@ import * as ts from 'typescript';
 import {isFatalDiagnosticError} from '../../../src/ngtsc/diagnostics';
 import {AbsoluteFsPath, absoluteFromSourceFile, relative} from '../../../src/ngtsc/file_system';
 import {Decorator} from '../../../src/ngtsc/reflection';
-import {DecoratorHandler, DetectResult, HandlerPrecedence} from '../../../src/ngtsc/transform';
+import {DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence} from '../../../src/ngtsc/transform';
 import {NgccClassSymbol} from '../host/ngcc_host';
 
 import {AnalyzedClass, MatchingHandler} from './types';
@@ -21,7 +21,7 @@ export function isWithinPackage(packagePath: AbsoluteFsPath, sourceFile: ts.Sour
 
 export function analyzeDecorators(
     classSymbol: NgccClassSymbol, decorators: Decorator[] | null,
-    handlers: DecoratorHandler<any, any>[]): AnalyzedClass|null {
+    handlers: DecoratorHandler<any, any>[], flags?: HandlerFlags): AnalyzedClass|null {
   const declaration = classSymbol.declaration.valueDeclaration;
   const matchingHandlers = handlers
                                .map(handler => {
@@ -64,7 +64,7 @@ export function analyzeDecorators(
   const allDiagnostics: ts.Diagnostic[] = [];
   for (const {handler, detected} of detections) {
     try {
-      const {analysis, diagnostics} = handler.analyze(declaration, detected.metadata);
+      const {analysis, diagnostics} = handler.analyze(declaration, detected.metadata, flags);
       if (diagnostics !== undefined) {
         allDiagnostics.push(...diagnostics);
       }

packages/compiler-cli/ngcc/src/host/esm2015_host.ts

@@ -344,10 +344,18 @@ export class Esm2015ReflectionHost extends TypeScriptReflectionHost implements N
     return superDeclaration;
   }
 
-  /** Gets all decorators of the given class symbol. */
+  /**
+   * Gets all decorators of the given class symbol. Any decorator that have been synthetically
+   * injected by a migration will not be present in the returned collection.
+   */
   getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[]|null {
     const {classDecorators} = this.acquireDecoratorInfo(symbol);
-    return classDecorators;
+    if (classDecorators === null) {
+      return null;
+    }
+
+    // Return a clone of the array to prevent consumers from mutating the cache.
+    return Array.from(classDecorators);
   }
 
   /**

packages/compiler-cli/ngcc/src/migrations/migration.ts

@@ -6,11 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as ts from 'typescript';
+
 import {MetadataReader} from '../../../src/ngtsc/metadata';
 import {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';
 import {ClassDeclaration, Decorator} from '../../../src/ngtsc/reflection';
+import {HandlerFlags} from '../../../src/ngtsc/transform';
 import {NgccReflectionHost} from '../host/ngcc_host';
 
+
 /**
  * Implement this interface and add it to the `DecorationAnalyzer.migrations` collection to get ngcc
  * to modify the analysis of the decorators in the program in order to migrate older code to work
@@ -41,5 +44,22 @@ export interface MigrationHost {
    * @param clazz the class to receive the new decorator.
    * @param decorator the decorator to inject.
    */
-  injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator): void;
+  injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator, flags?: HandlerFlags):
+      void;
+
+  /**
+   * Retrieves all decorators that are associated with the class, including synthetic decorators
+   * that have been injected before.
+   * @param clazz the class for which all decorators are retrieved.
+   * @returns the list of the decorators, or null if the class was not decorated.
+   */
+  getAllDecorators(clazz: ClassDeclaration): Decorator[]|null;
+
+  /**
+   * Determines whether the provided class in within scope of the entry-point that is currently
+   * being compiled.
+   * @param clazz the class for which to determine whether it is within the current entry-point.
+   * @returns true if the file is part of the compiled entry-point, false otherwise.
+   */
+  isInScope(clazz: ClassDeclaration): boolean;
 }