refactor(ivy): rename and move ngcc `Parsed...` to `Decorated...` (#26082)

PR Close #26082

packages/compiler-cli/src/ngcc/src/analyzer.ts

@@ -13,11 +13,11 @@ import {BaseDefDecoratorHandler, ComponentDecoratorHandler, DirectiveDecoratorHa
 import {CompileResult, DecoratorHandler} from '../../ngtsc/transform';
 
 import {NgccReflectionHost} from './host/ngcc_host';
-import {ParsedClass} from './parsing/parsed_class';
+import {DecoratedClass} from './host/decorated_class';
-import {ParsedFile} from './parsing/parsed_file';
+import {DecoratedFile} from './host/decorated_file';
 import {isDefined} from './utils';
 
-export interface AnalyzedClass<A = any, M = any> extends ParsedClass {
+export interface AnalyzedClass<A = any, M = any> extends DecoratedClass {
   handler: DecoratorHandler<A, M>;
   analysis: any;
   diagnostics?: ts.Diagnostic[];
@@ -61,11 +61,11 @@ export class Analyzer {
       private rootDirs: string[], private isCore: boolean) {}
 
   /**
-   * Analyize a parsed file to generate the information about decorated classes that
+   * Analyze a decorated file to generate the information about decorated classes that
    * should be converted to use ivy definitions.
    * @param file The file to be analysed for decorated classes.
    */
-  analyzeFile(file: ParsedFile): AnalyzedFile {
+  analyzeFile(file: DecoratedFile): AnalyzedFile {
     const constantPool = new ConstantPool();
     const analyzedClasses =
         file.decoratedClasses.map(clazz => this.analyzeClass(constantPool, clazz))
@@ -77,7 +77,7 @@ export class Analyzer {
     };
   }
 
-  protected analyzeClass(pool: ConstantPool, clazz: ParsedClass): AnalyzedClass|undefined {
+  protected analyzeClass(pool: ConstantPool, clazz: DecoratedClass): AnalyzedClass|undefined {
     const matchingHandlers = this.handlers
                                  .map(handler => ({
                                         handler,

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

@@ -11,11 +11,11 @@ import {Decorator} from '../../../ngtsc/host';
 
 /**
  * A simple container that holds the details of a decorated class that has been
- * parsed out of a package.
+ * found in a `DecoratedFile`.
  */
-export class ParsedClass {
+export class DecoratedClass {
   /**
-   * Initialize a `DecoratedClass` that was found by parsing a package.
+   * Initialize a `DecoratedClass` that was found in a `DecoratedFile`.
    * @param name The name of the class that has been found. This is mostly used
    * for informational purposes.
    * @param declaration The TypeScript AST node where this class is declared

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

@@ -7,17 +7,15 @@
  */
 
 import * as ts from 'typescript';
-import {ParsedClass} from './parsed_class';
+import {DecoratedClass} from './decorated_class';
 
 /**
- * Information about a source file that has been parsed to
+ * Information about a source file that contains decorated exported classes.
- * extract all the decorated exported classes.
  */
-export class ParsedFile {
+export class DecoratedFile {
   /**
-   * The decorated exported classes that have been parsed out
+   * The decorated exported classes that have been found in the file.
-   * from the file.
    */
-  public decoratedClasses: ParsedClass[] = [];
+  public decoratedClasses: DecoratedClass[] = [];
   constructor(public sourceFile: ts.SourceFile) {}
 }

packages/compiler-cli/src/ngcc/src/parsing/esm2015_parser.ts

@@ -9,20 +9,20 @@
 import * as ts from 'typescript';
 
 import {NgccReflectionHost} from '../host/ngcc_host';
+import {DecoratedClass} from '../host/decorated_class';
+import {DecoratedFile} from '../host/decorated_file';
 import {getOriginalSymbol, isDefined} from '../utils';
 
 import {FileParser} from './file_parser';
-import {ParsedClass} from './parsed_class';
-import {ParsedFile} from './parsed_file';
 
 export class Esm2015FileParser implements FileParser {
   checker = this.program.getTypeChecker();
 
   constructor(protected program: ts.Program, protected host: NgccReflectionHost) {}
 
-  parseFile(file: ts.SourceFile): ParsedFile[] {
+  parseFile(file: ts.SourceFile): DecoratedFile[] {
     const moduleSymbol = this.checker.getSymbolAtLocation(file);
-    const map = new Map<ts.SourceFile, ParsedFile>();
+    const map = new Map<ts.SourceFile, DecoratedFile>();
     if (moduleSymbol) {
       const exportedSymbols =
           this.checker.getExportsOfModule(moduleSymbol).map(getOriginalSymbol(this.checker));
@@ -38,7 +38,7 @@ export class Esm2015FileParser implements FileParser {
                       undefined;
                   const decorators = this.host.getDecoratorsOfDeclaration(declaration);
                   return decorators && isDefined(name) ?
-                      new ParsedClass(name, declaration, decorators) :
+                      new DecoratedClass(name, declaration, decorators) :
                       undefined;
                 }
                 return undefined;
@@ -48,7 +48,7 @@ export class Esm2015FileParser implements FileParser {
       decoratedClasses.forEach(clazz => {
         const file = clazz.declaration.getSourceFile();
         if (!map.has(file)) {
-          map.set(file, new ParsedFile(file));
+          map.set(file, new DecoratedFile(file));
         }
         map.get(file) !.decoratedClasses.push(clazz);
       });

packages/compiler-cli/src/ngcc/src/parsing/esm5_parser.ts

@@ -9,11 +9,11 @@
 import * as ts from 'typescript';
 
 import {NgccReflectionHost} from '../host/ngcc_host';
+import {DecoratedClass} from '../host/decorated_class';
+import {DecoratedFile} from '../host/decorated_file';
 import {getNameText, getOriginalSymbol, isDefined} from '../utils';
 
 import {FileParser} from './file_parser';
-import {ParsedClass} from './parsed_class';
-import {ParsedFile} from './parsed_file';
 
 
 
@@ -27,13 +27,13 @@ export class Esm5FileParser implements FileParser {
 
   constructor(protected program: ts.Program, protected host: NgccReflectionHost) {}
 
-  parseFile(file: ts.SourceFile): ParsedFile[] {
+  parseFile(file: ts.SourceFile): DecoratedFile[] {
     const moduleSymbol = this.checker.getSymbolAtLocation(file);
-    const map = new Map<ts.SourceFile, ParsedFile>();
+    const map = new Map<ts.SourceFile, DecoratedFile>();
     const getParsedClass = (declaration: ts.VariableDeclaration) => {
       const decorators = this.host.getDecoratorsOfDeclaration(declaration);
       if (decorators) {
-        return new ParsedClass(getNameText(declaration.name), declaration, decorators);
+        return new DecoratedClass(getNameText(declaration.name), declaration, decorators);
       }
     };
 
@@ -49,7 +49,7 @@ export class Esm5FileParser implements FileParser {
       decoratedClasses.forEach(clazz => {
         const file = clazz.declaration.getSourceFile();
         if (!map.has(file)) {
-          map.set(file, new ParsedFile(file));
+          map.set(file, new DecoratedFile(file));
         }
         map.get(file) !.decoratedClasses.push(clazz);
       });

packages/compiler-cli/src/ngcc/src/parsing/file_parser.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as ts from 'typescript';
-import {ParsedFile} from './parsed_file';
+import {DecoratedFile} from '../host/decorated_file';
 
 /**
  * Classes that implement this interface can parse a file in a package to
@@ -31,5 +31,5 @@ export interface FileParser {
    * @param file The the entry point file for identifying classes to process.
    * @returns A `ParsedFiles` collection that holds the decorated classes and import information.
    */
-  parseFile(file: ts.SourceFile): ParsedFile[];
+  parseFile(file: ts.SourceFile): DecoratedFile[];
 }

packages/compiler-cli/src/ngcc/test/analyzer_spec.ts

@@ -10,8 +10,8 @@ import {Decorator} from '../../ngtsc/host';
 import {DecoratorHandler} from '../../ngtsc/transform';
 import {AnalyzedFile, Analyzer} from '../src/analyzer';
 import {Fesm2015ReflectionHost} from '../src/host/fesm2015_host';
-import {ParsedClass} from '../src/parsing/parsed_class';
+import {DecoratedClass} from '../src/host/decorated_class';
-import {ParsedFile} from '../src/parsing/parsed_file';
+import {DecoratedFile} from '../src/host/decorated_file';
 import {getDeclaration, makeProgram} from './helpers/utils';
 
 const TEST_PROGRAM = {
@@ -49,10 +49,11 @@ function createTestHandler() {
 }
 
 function createParsedFile(program: ts.Program) {
-  const file = new ParsedFile(program.getSourceFile('test.js') !);
+  const file = new DecoratedFile(program.getSourceFile('test.js') !);
 
   const componentClass = getDeclaration(program, 'test.js', 'MyComponent', ts.isClassDeclaration);
-  file.decoratedClasses.push(new ParsedClass('MyComponent', {} as any, [{
+  file.decoratedClasses.push(
+      new DecoratedClass('MyComponent', {} as any, [{
                            name: 'Component',
                            import: {from: '@angular/core', name: 'Component'},
                            node: null as any,
@@ -60,7 +61,8 @@ function createParsedFile(program: ts.Program) {
                          }]));
 
   const serviceClass = getDeclaration(program, 'test.js', 'MyService', ts.isClassDeclaration);
-  file.decoratedClasses.push(new ParsedClass('MyService', {} as any, [{
+  file.decoratedClasses.push(
+      new DecoratedClass('MyService', {} as any, [{
                            name: 'Injectable',
                            import: {from: '@angular/core', name: 'Injectable'},
                            node: null as any,