@angular/core 10.0.0 → 10.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "10.0.0",
+  "version": "10.0.4",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/schematics/migrations/undecorated-classes-with-decorated-fields/transform.d.ts

@@ -52,5 +52,12 @@ export declare class UndecoratedClassesWithDecoratedFieldsTransform {
      * considered Angular features..
      */
     private _determineClassKind;
+    /**
+     * Checks whether a given class has been reported as ambiguous in previous
+     * migration run. e.g. when build targets are migrated first, and then test
+     * targets that have an overlap with build source files, the same class
+     * could be detected as ambiguous.
+     */
+    private _hasBeenReportedAsAmbiguous;
 }
 export {};

package/schematics/migrations/undecorated-classes-with-decorated-fields/transform.js

@@ -47,12 +47,23 @@
      */
     const AMBIGUOUS_LIFECYCLE_HOOKS = new Set(['ngOnDestroy']);
     /** Describes how a given class is used in the context of Angular. */
-    var ClassKind;
-    (function (ClassKind) {
-        ClassKind[ClassKind["DIRECTIVE"] = 0] = "DIRECTIVE";
-        ClassKind[ClassKind["AMBIGUOUS"] = 1] = "AMBIGUOUS";
-        ClassKind[ClassKind["UNKNOWN"] = 2] = "UNKNOWN";
-    })(ClassKind || (ClassKind = {}));
+    var InferredKind;
+    (function (InferredKind) {
+        InferredKind[InferredKind["DIRECTIVE"] = 0] = "DIRECTIVE";
+        InferredKind[InferredKind["AMBIGUOUS"] = 1] = "AMBIGUOUS";
+        InferredKind[InferredKind["UNKNOWN"] = 2] = "UNKNOWN";
+    })(InferredKind || (InferredKind = {}));
+    /** Describes possible types of Angular declarations. */
+    var DeclarationType;
+    (function (DeclarationType) {
+        DeclarationType[DeclarationType["DIRECTIVE"] = 0] = "DIRECTIVE";
+        DeclarationType[DeclarationType["COMPONENT"] = 1] = "COMPONENT";
+        DeclarationType[DeclarationType["ABSTRACT_DIRECTIVE"] = 2] = "ABSTRACT_DIRECTIVE";
+        DeclarationType[DeclarationType["PIPE"] = 3] = "PIPE";
+        DeclarationType[DeclarationType["INJECTABLE"] = 4] = "INJECTABLE";
+    })(DeclarationType || (DeclarationType = {}));
+    /** TODO message that is added to ambiguous classes using Angular features. */
+    const AMBIGUOUS_CLASS_TODO = 'Add Angular decorator.';
     class UndecoratedClassesWithDecoratedFieldsTransform {
         constructor(typeChecker, getUpdateRecorder) {
             this.typeChecker = typeChecker;
@@ -69,8 +80,8 @@
          * indicating that a given class uses Angular features. https://hackmd.io/vuQfavzfRG6KUCtU7oK_EA
          */
         migrate(sourceFiles) {
-            const { result, ambiguous } = this._findUndecoratedAbstractDirectives(sourceFiles);
-            result.forEach(node => {
+            const { detectedAbstractDirectives, ambiguousClasses } = this._findUndecoratedAbstractDirectives(sourceFiles);
+            detectedAbstractDirectives.forEach(node => {
                 const sourceFile = node.getSourceFile();
                 const recorder = this.getUpdateRecorder(sourceFile);
                 const directiveExpr = this.importManager.addImportToSourceFile(sourceFile, 'Directive', '@angular/core');
@@ -81,11 +92,17 @@
             // determine whether the class is used as directive, service or pipe. The migration
             // could potentially determine the type by checking NgModule definitions or inheritance
             // of other known declarations, but this is out of scope and a TODO/failure is sufficient.
-            return Array.from(ambiguous).reduce((failures, node) => {
+            return Array.from(ambiguousClasses).reduce((failures, node) => {
+                // If the class has been reported as ambiguous before, skip adding a TODO and
+                // printing an error. A class could be visited multiple times when it's part
+                // of multiple build targets in the CLI project.
+                if (this._hasBeenReportedAsAmbiguous(node)) {
+                    return failures;
+                }
                 const sourceFile = node.getSourceFile();
                 const recorder = this.getUpdateRecorder(sourceFile);
                 // Add a TODO to the class that uses Angular features but is not decorated.
-                recorder.addClassTodo(node, `Add Angular decorator.`);
+                recorder.addClassTodo(node, AMBIGUOUS_CLASS_TODO);
                 // Add an error for the class that will be printed in the `ng update` output.
                 return failures.concat({
                     node,
@@ -104,58 +121,78 @@
          * directives. Those are ambiguous and could be either Directive, Pipe or service.
          */
         _findUndecoratedAbstractDirectives(sourceFiles) {
-            const result = new Set();
+            const ambiguousClasses = new Set();
+            const declarations = new WeakMap();
+            const detectedAbstractDirectives = new Set();
             const undecoratedClasses = new Set();
-            const nonAbstractDirectives = new WeakSet();
-            const abstractDirectives = new WeakSet();
-            const ambiguous = new Set();
             const visitNode = (node) => {
                 node.forEachChild(visitNode);
                 if (!ts.isClassDeclaration(node)) {
                     return;
                 }
-                const { isDirectiveOrComponent, isAbstractDirective, kind } = this._analyzeClassDeclaration(node);
-                if (isDirectiveOrComponent) {
-                    if (isAbstractDirective) {
-                        abstractDirectives.add(node);
-                    }
-                    else {
-                        nonAbstractDirectives.add(node);
-                    }
+                const { inferredKind, decoratedType } = this._analyzeClassDeclaration(node);
+                if (decoratedType !== null) {
+                    declarations.set(node, decoratedType);
+                    return;
+                }
+                if (inferredKind === InferredKind.DIRECTIVE) {
+                    detectedAbstractDirectives.add(node);
                 }
-                else if (kind === ClassKind.DIRECTIVE) {
-                    abstractDirectives.add(node);
-                    result.add(node);
+                else if (inferredKind === InferredKind.AMBIGUOUS) {
+                    ambiguousClasses.add(node);
                 }
                 else {
-                    if (kind === ClassKind.AMBIGUOUS) {
-                        ambiguous.add(node);
-                    }
                     undecoratedClasses.add(node);
                 }
             };
             sourceFiles.forEach(sourceFile => sourceFile.forEachChild(visitNode));
-            // We collected all undecorated class declarations which inherit from abstract directives.
-            // For such abstract directives, the derived classes also need to be migrated.
-            undecoratedClasses.forEach(node => {
-                for (const { node: baseClass } of find_base_classes_1.findBaseClassDeclarations(node, this.typeChecker)) {
-                    // If the undecorated class inherits from a non-abstract directive, skip the current
-                    // class. We do this because undecorated classes which inherit metadata from non-abstract
-                    // directives are handled in the `undecorated-classes-with-di` migration that copies
-                    // inherited metadata into an explicit decorator.
-                    if (nonAbstractDirectives.has(baseClass)) {
+            /**
+             * Checks the inheritance of the given set of classes. It removes classes from the
+             * detected abstract directives set when they inherit from a non-abstract Angular
+             * declaration. e.g. an abstract directive can never extend from a component.
+             *
+             * If a class inherits from an abstract directive though, we will migrate them too
+             * as derived classes also need to be decorated. This has been done for a simpler mental
+             * model and reduced complexity in the Angular compiler. See migration plan document.
+             */
+            const checkInheritanceOfClasses = (classes) => {
+                classes.forEach(node => {
+                    for (const { node: baseClass } of find_base_classes_1.findBaseClassDeclarations(node, this.typeChecker)) {
+                        if (!declarations.has(baseClass)) {
+                            continue;
+                        }
+                        // If the undecorated class inherits from an abstract directive, always migrate it.
+                        // Derived undecorated classes of abstract directives are always also considered
+                        // abstract directives and need to be decorated too. This is necessary as otherwise
+                        // the inheritance chain cannot be resolved by the Angular compiler. e.g. when it
+                        // flattens directive metadata for type checking. In the other case, we never want
+                        // to migrate a class if it extends from a non-abstract Angular declaration. That
+                        // is an unsupported pattern as of v9 and was previously handled with the
+                        // `undecorated-classes-with-di` migration (which copied the inherited decorator).
+                        if (declarations.get(baseClass) === DeclarationType.ABSTRACT_DIRECTIVE) {
+                            detectedAbstractDirectives.add(node);
+                        }
+                        else {
+                            detectedAbstractDirectives.delete(node);
+                        }
+                        ambiguousClasses.delete(node);
                         break;
                     }
-                    else if (abstractDirectives.has(baseClass)) {
-                        result.add(node);
-                        // In case the undecorated class previously could not be detected as directive,
-                        // remove it from the ambiguous set as we now know that it's a guaranteed directive.
-                        ambiguous.delete(node);
-                        break;
-                    }
-                }
-            });
-            return { result, ambiguous };
+                });
+            };
+            // Check inheritance of any detected abstract directive. We want to remove
+            // classes that are not eligible abstract directives due to inheritance. i.e.
+            // if a class extends from a component, it cannot be a derived abstract directive.
+            checkInheritanceOfClasses(detectedAbstractDirectives);
+            // Update the class declarations to reflect the detected abstract directives. This is
+            // then used later when we check for undecorated classes that inherit from an abstract
+            // directive and need to be decorated.
+            detectedAbstractDirectives.forEach(n => declarations.set(n, DeclarationType.ABSTRACT_DIRECTIVE));
+            // Check ambiguous and undecorated classes if they inherit from an abstract directive.
+            // If they do, we want to migrate them too. See function definition for more details.
+            checkInheritanceOfClasses(ambiguousClasses);
+            checkInheritanceOfClasses(undecoratedClasses);
+            return { detectedAbstractDirectives, ambiguousClasses };
         }
         /**
          * Analyzes the given class declaration by determining whether the class
@@ -163,18 +200,32 @@
          */
         _analyzeClassDeclaration(node) {
             const ngDecorators = node.decorators && ng_decorators_1.getAngularDecorators(this.typeChecker, node.decorators);
-            const kind = this._determineClassKind(node);
+            const inferredKind = this._determineClassKind(node);
             if (ngDecorators === undefined || ngDecorators.length === 0) {
-                return { isDirectiveOrComponent: false, isAbstractDirective: false, kind };
+                return { decoratedType: null, inferredKind };
             }
             const directiveDecorator = ngDecorators.find(({ name }) => name === 'Directive');
             const componentDecorator = ngDecorators.find(({ name }) => name === 'Component');
+            const pipeDecorator = ngDecorators.find(({ name }) => name === 'Pipe');
+            const injectableDecorator = ngDecorators.find(({ name }) => name === 'Injectable');
             const isAbstractDirective = directiveDecorator !== undefined && this._isAbstractDirective(directiveDecorator);
-            return {
-                isDirectiveOrComponent: !!directiveDecorator || !!componentDecorator,
-                isAbstractDirective,
-                kind,
-            };
+            let decoratedType = null;
+            if (isAbstractDirective) {
+                decoratedType = DeclarationType.ABSTRACT_DIRECTIVE;
+            }
+            else if (componentDecorator !== undefined) {
+                decoratedType = DeclarationType.COMPONENT;
+            }
+            else if (directiveDecorator !== undefined) {
+                decoratedType = DeclarationType.DIRECTIVE;
+            }
+            else if (pipeDecorator !== undefined) {
+                decoratedType = DeclarationType.PIPE;
+            }
+            else if (injectableDecorator !== undefined) {
+                decoratedType = DeclarationType.INJECTABLE;
+            }
+            return { decoratedType, inferredKind };
         }
         /**
          * Checks whether the given decorator resolves to an abstract directive. An directive is
@@ -203,32 +254,47 @@
          * considered Angular features..
          */
         _determineClassKind(node) {
-            let usage = ClassKind.UNKNOWN;
+            let usage = InferredKind.UNKNOWN;
             for (const member of node.members) {
                 const propertyName = member.name !== undefined ? property_name_1.getPropertyNameText(member.name) : null;
                 // If the class declares any of the known directive lifecycle hooks, we can
                 // immediately exit the loop as the class is guaranteed to be a directive.
                 if (propertyName !== null && DIRECTIVE_LIFECYCLE_HOOKS.has(propertyName)) {
-                    return ClassKind.DIRECTIVE;
+                    return InferredKind.DIRECTIVE;
                 }
                 const ngDecorators = member.decorators !== undefined ?
                     ng_decorators_1.getAngularDecorators(this.typeChecker, member.decorators) :
                     [];
                 for (const { name } of ngDecorators) {
                     if (DIRECTIVE_FIELD_DECORATORS.has(name)) {
-                        return ClassKind.DIRECTIVE;
+                        return InferredKind.DIRECTIVE;
                     }
                 }
                 // If the class declares any of the lifecycle hooks that do not guarantee that
                 // the given class is a directive, update the kind and continue looking for other
                 // members that would unveil a more specific kind (i.e. being a directive).
                 if (propertyName !== null && AMBIGUOUS_LIFECYCLE_HOOKS.has(propertyName)) {
-                    usage = ClassKind.AMBIGUOUS;
+                    usage = InferredKind.AMBIGUOUS;
                 }
             }
             return usage;
         }
+        /**
+         * Checks whether a given class has been reported as ambiguous in previous
+         * migration run. e.g. when build targets are migrated first, and then test
+         * targets that have an overlap with build source files, the same class
+         * could be detected as ambiguous.
+         */
+        _hasBeenReportedAsAmbiguous(node) {
+            const sourceFile = node.getSourceFile();
+            const leadingComments = ts.getLeadingCommentRanges(sourceFile.text, node.pos);
+            if (leadingComments === undefined) {
+                return false;
+            }
+            return leadingComments.some(({ kind, pos, end }) => kind === ts.SyntaxKind.SingleLineCommentTrivia &&
+                sourceFile.text.substring(pos, end).includes(`TODO: ${AMBIGUOUS_CLASS_TODO}`));
+        }
     }
     exports.UndecoratedClassesWithDecoratedFieldsTransform = UndecoratedClassesWithDecoratedFieldsTransform;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/undecorated-classes-with-decorated-fields/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 {PartialEvaluator} from '@angular/compiler-cli/src/ngtsc/partial_evaluator';\nimport {reflectObjectLiteral, TypeScriptReflectionHost} from '@angular/compiler-cli/src/ngtsc/reflection';\nimport * as ts from 'typescript';\n\nimport {ImportManager} from '../../utils/import_manager';\nimport {getAngularDecorators, NgDecorator} from '../../utils/ng_decorators';\nimport {findBaseClassDeclarations} from '../../utils/typescript/find_base_classes';\nimport {unwrapExpression} from '../../utils/typescript/functions';\nimport {getPropertyNameText} from '../../utils/typescript/property_name';\n\nimport {UpdateRecorder} from './update_recorder';\n\n/**\n * Set of known decorators that indicate that the current class needs a directive\n * definition. These decorators are always specific to directives.\n */\nconst DIRECTIVE_FIELD_DECORATORS = new Set([\n  'Input', 'Output', 'ViewChild', 'ViewChildren', 'ContentChild', 'ContentChildren', 'HostBinding',\n  'HostListener'\n]);\n\n/**\n * Set of known lifecycle hooks that indicate that the current class needs a directive\n * definition. These lifecycle hooks are always specific to directives.\n */\nconst DIRECTIVE_LIFECYCLE_HOOKS = new Set([\n  'ngOnChanges', 'ngOnInit', 'ngDoCheck', 'ngAfterViewInit', 'ngAfterViewChecked',\n  'ngAfterContentInit', 'ngAfterContentChecked'\n]);\n\n/**\n * Set of known lifecycle hooks that indicate that a given class uses Angular\n * features, but it's ambiguous whether it is a directive or service.\n */\nconst AMBIGUOUS_LIFECYCLE_HOOKS = new Set(['ngOnDestroy']);\n\n/** Describes how a given class is used in the context of Angular. */\nenum ClassKind {\n  DIRECTIVE,\n  AMBIGUOUS,\n  UNKNOWN,\n}\n\n/** Analyzed class declaration. */\ninterface AnalyzedClass {\n  /** Whether the class is decorated with @Directive or @Component. */\n  isDirectiveOrComponent: boolean;\n  /** Whether the class is an abstract directive. */\n  isAbstractDirective: boolean;\n  /** Kind of the given class in terms of Angular. */\n  kind: ClassKind;\n}\n\ninterface AnalysisFailure {\n  node: ts.Node;\n  message: string;\n}\n\nexport class UndecoratedClassesWithDecoratedFieldsTransform {\n  private printer = ts.createPrinter();\n  private importManager = new ImportManager(this.getUpdateRecorder, this.printer);\n  private reflectionHost = new TypeScriptReflectionHost(this.typeChecker);\n  private partialEvaluator = new PartialEvaluator(this.reflectionHost, this.typeChecker, null);\n\n  constructor(\n      private typeChecker: ts.TypeChecker,\n      private getUpdateRecorder: (sf: ts.SourceFile) => UpdateRecorder) {}\n\n  /**\n   * Migrates the specified source files. The transform adds the abstract `@Directive`\n   * decorator to undecorated classes that use Angular features. Class members which\n   * are decorated with any Angular decorator, or class members for lifecycle hooks are\n   * indicating that a given class uses Angular features. https://hackmd.io/vuQfavzfRG6KUCtU7oK_EA\n   */\n  migrate(sourceFiles: ts.SourceFile[]): AnalysisFailure[] {\n    const {result, ambiguous} = this._findUndecoratedAbstractDirectives(sourceFiles);\n\n\n    result.forEach(node => {\n      const sourceFile = node.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n      const directiveExpr =\n          this.importManager.addImportToSourceFile(sourceFile, 'Directive', '@angular/core');\n      const decoratorExpr = ts.createDecorator(ts.createCall(directiveExpr, undefined, undefined));\n      recorder.addClassDecorator(\n          node, this.printer.printNode(ts.EmitHint.Unspecified, decoratorExpr, sourceFile));\n    });\n\n    // Ambiguous classes clearly use Angular features, but the migration is unable to\n    // determine whether the class is used as directive, service or pipe. The migration\n    // could potentially determine the type by checking NgModule definitions or inheritance\n    // of other known declarations, but this is out of scope and a TODO/failure is sufficient.\n    return Array.from(ambiguous).reduce((failures, node) => {\n      const sourceFile = node.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n\n      // Add a TODO to the class that uses Angular features but is not decorated.\n      recorder.addClassTodo(node, `Add Angular decorator.`);\n\n      // Add an error for the class that will be printed in the `ng update` output.\n      return failures.concat({\n        node,\n        message: 'Class uses Angular features but cannot be migrated automatically. Please ' +\n            'add an appropriate Angular decorator.'\n      });\n    }, [] as AnalysisFailure[]);\n  }\n\n  /** Records all changes that were made in the import manager. */\n  recordChanges() {\n    this.importManager.recordChanges();\n  }\n\n  /**\n   * Finds undecorated abstract directives in the specified source files. Also returns\n   * a set of undecorated classes which could not be detected as guaranteed abstract\n   * directives. Those are ambiguous and could be either Directive, Pipe or service.\n   */\n  private _findUndecoratedAbstractDirectives(sourceFiles: ts.SourceFile[]) {\n    const result = new Set<ts.ClassDeclaration>();\n    const undecoratedClasses = new Set<ts.ClassDeclaration>();\n    const nonAbstractDirectives = new WeakSet<ts.ClassDeclaration>();\n    const abstractDirectives = new WeakSet<ts.ClassDeclaration>();\n    const ambiguous = new Set<ts.ClassDeclaration>();\n\n    const visitNode = (node: ts.Node) => {\n      node.forEachChild(visitNode);\n      if (!ts.isClassDeclaration(node)) {\n        return;\n      }\n      const {isDirectiveOrComponent, isAbstractDirective, kind} =\n          this._analyzeClassDeclaration(node);\n      if (isDirectiveOrComponent) {\n        if (isAbstractDirective) {\n          abstractDirectives.add(node);\n        } else {\n          nonAbstractDirectives.add(node);\n        }\n      } else if (kind === ClassKind.DIRECTIVE) {\n        abstractDirectives.add(node);\n        result.add(node);\n      } else {\n        if (kind === ClassKind.AMBIGUOUS) {\n          ambiguous.add(node);\n        }\n        undecoratedClasses.add(node);\n      }\n    };\n\n    sourceFiles.forEach(sourceFile => sourceFile.forEachChild(visitNode));\n\n    // We collected all undecorated class declarations which inherit from abstract directives.\n    // For such abstract directives, the derived classes also need to be migrated.\n    undecoratedClasses.forEach(node => {\n      for (const {node: baseClass} of findBaseClassDeclarations(node, this.typeChecker)) {\n        // If the undecorated class inherits from a non-abstract directive, skip the current\n        // class. We do this because undecorated classes which inherit metadata from non-abstract\n        // directives are handled in the `undecorated-classes-with-di` migration that copies\n        // inherited metadata into an explicit decorator.\n        if (nonAbstractDirectives.has(baseClass)) {\n          break;\n        } else if (abstractDirectives.has(baseClass)) {\n          result.add(node);\n          // In case the undecorated class previously could not be detected as directive,\n          // remove it from the ambiguous set as we now know that it's a guaranteed directive.\n          ambiguous.delete(node);\n          break;\n        }\n      }\n    });\n\n    return {result, ambiguous};\n  }\n\n  /**\n   * Analyzes the given class declaration by determining whether the class\n   * is a directive, is an abstract directive, or uses Angular features.\n   */\n  private _analyzeClassDeclaration(node: ts.ClassDeclaration): AnalyzedClass {\n    const ngDecorators = node.decorators && getAngularDecorators(this.typeChecker, node.decorators);\n    const kind = this._determineClassKind(node);\n    if (ngDecorators === undefined || ngDecorators.length === 0) {\n      return {isDirectiveOrComponent: false, isAbstractDirective: false, kind};\n    }\n    const directiveDecorator = ngDecorators.find(({name}) => name === 'Directive');\n    const componentDecorator = ngDecorators.find(({name}) => name === 'Component');\n    const isAbstractDirective =\n        directiveDecorator !== undefined && this._isAbstractDirective(directiveDecorator);\n    return {\n      isDirectiveOrComponent: !!directiveDecorator || !!componentDecorator,\n      isAbstractDirective,\n      kind,\n    };\n  }\n\n  /**\n   * Checks whether the given decorator resolves to an abstract directive. An directive is\n   * considered \"abstract\" if there is no selector specified.\n   */\n  private _isAbstractDirective({node}: NgDecorator): boolean {\n    const metadataArgs = node.expression.arguments;\n    if (metadataArgs.length === 0) {\n      return true;\n    }\n    const metadataExpr = unwrapExpression(metadataArgs[0]);\n    if (!ts.isObjectLiteralExpression(metadataExpr)) {\n      return false;\n    }\n    const metadata = reflectObjectLiteral(metadataExpr);\n    if (!metadata.has('selector')) {\n      return false;\n    }\n    const selector = this.partialEvaluator.evaluate(metadata.get('selector')!);\n    return selector == null;\n  }\n\n  /**\n   * Determines the kind of a given class in terms of Angular. The method checks\n   * whether the given class has members that indicate the use of Angular features.\n   * e.g. lifecycle hooks or decorated members like `@Input` or `@Output` are\n   * considered Angular features..\n   */\n  private _determineClassKind(node: ts.ClassDeclaration): ClassKind {\n    let usage = ClassKind.UNKNOWN;\n\n    for (const member of node.members) {\n      const propertyName = member.name !== undefined ? getPropertyNameText(member.name) : null;\n\n      // If the class declares any of the known directive lifecycle hooks, we can\n      // immediately exit the loop as the class is guaranteed to be a directive.\n      if (propertyName !== null && DIRECTIVE_LIFECYCLE_HOOKS.has(propertyName)) {\n        return ClassKind.DIRECTIVE;\n      }\n\n      const ngDecorators = member.decorators !== undefined ?\n          getAngularDecorators(this.typeChecker, member.decorators) :\n          [];\n      for (const {name} of ngDecorators) {\n        if (DIRECTIVE_FIELD_DECORATORS.has(name)) {\n          return ClassKind.DIRECTIVE;\n        }\n      }\n\n      // If the class declares any of the lifecycle hooks that do not guarantee that\n      // the given class is a directive, update the kind and continue looking for other\n      // members that would unveil a more specific kind (i.e. being a directive).\n      if (propertyName !== null && AMBIGUOUS_LIFECYCLE_HOOKS.has(propertyName)) {\n        usage = ClassKind.AMBIGUOUS;\n      }\n    }\n\n    return usage;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/undecorated-classes-with-decorated-fields/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 {PartialEvaluator} from '@angular/compiler-cli/src/ngtsc/partial_evaluator';\nimport {reflectObjectLiteral, TypeScriptReflectionHost} from '@angular/compiler-cli/src/ngtsc/reflection';\nimport * as ts from 'typescript';\n\nimport {ImportManager} from '../../utils/import_manager';\nimport {getAngularDecorators, NgDecorator} from '../../utils/ng_decorators';\nimport {findBaseClassDeclarations} from '../../utils/typescript/find_base_classes';\nimport {unwrapExpression} from '../../utils/typescript/functions';\nimport {getPropertyNameText} from '../../utils/typescript/property_name';\n\nimport {UpdateRecorder} from './update_recorder';\n\n/**\n * Set of known decorators that indicate that the current class needs a directive\n * definition. These decorators are always specific to directives.\n */\nconst DIRECTIVE_FIELD_DECORATORS = new Set([\n  'Input', 'Output', 'ViewChild', 'ViewChildren', 'ContentChild', 'ContentChildren', 'HostBinding',\n  'HostListener'\n]);\n\n/**\n * Set of known lifecycle hooks that indicate that the current class needs a directive\n * definition. These lifecycle hooks are always specific to directives.\n */\nconst DIRECTIVE_LIFECYCLE_HOOKS = new Set([\n  'ngOnChanges', 'ngOnInit', 'ngDoCheck', 'ngAfterViewInit', 'ngAfterViewChecked',\n  'ngAfterContentInit', 'ngAfterContentChecked'\n]);\n\n/**\n * Set of known lifecycle hooks that indicate that a given class uses Angular\n * features, but it's ambiguous whether it is a directive or service.\n */\nconst AMBIGUOUS_LIFECYCLE_HOOKS = new Set(['ngOnDestroy']);\n\n/** Describes how a given class is used in the context of Angular. */\nenum InferredKind {\n  DIRECTIVE,\n  AMBIGUOUS,\n  UNKNOWN,\n}\n\n/** Describes possible types of Angular declarations. */\nenum DeclarationType {\n  DIRECTIVE,\n  COMPONENT,\n  ABSTRACT_DIRECTIVE,\n  PIPE,\n  INJECTABLE,\n}\n\n/** Analyzed class declaration. */\ninterface AnalyzedClass {\n  /** Type of declaration that is determined through an applied decorator. */\n  decoratedType: DeclarationType|null;\n  /** Inferred class kind in terms of Angular. */\n  inferredKind: InferredKind;\n}\n\ninterface AnalysisFailure {\n  node: ts.Node;\n  message: string;\n}\n\n/** TODO message that is added to ambiguous classes using Angular features. */\nconst AMBIGUOUS_CLASS_TODO = 'Add Angular decorator.';\n\nexport class UndecoratedClassesWithDecoratedFieldsTransform {\n  private printer = ts.createPrinter();\n  private importManager = new ImportManager(this.getUpdateRecorder, this.printer);\n  private reflectionHost = new TypeScriptReflectionHost(this.typeChecker);\n  private partialEvaluator = new PartialEvaluator(this.reflectionHost, this.typeChecker, null);\n\n  constructor(\n      private typeChecker: ts.TypeChecker,\n      private getUpdateRecorder: (sf: ts.SourceFile) => UpdateRecorder) {}\n\n  /**\n   * Migrates the specified source files. The transform adds the abstract `@Directive`\n   * decorator to undecorated classes that use Angular features. Class members which\n   * are decorated with any Angular decorator, or class members for lifecycle hooks are\n   * indicating that a given class uses Angular features. https://hackmd.io/vuQfavzfRG6KUCtU7oK_EA\n   */\n  migrate(sourceFiles: ts.SourceFile[]): AnalysisFailure[] {\n    const {detectedAbstractDirectives, ambiguousClasses} =\n        this._findUndecoratedAbstractDirectives(sourceFiles);\n\n    detectedAbstractDirectives.forEach(node => {\n      const sourceFile = node.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n      const directiveExpr =\n          this.importManager.addImportToSourceFile(sourceFile, 'Directive', '@angular/core');\n      const decoratorExpr = ts.createDecorator(ts.createCall(directiveExpr, undefined, undefined));\n      recorder.addClassDecorator(\n          node, this.printer.printNode(ts.EmitHint.Unspecified, decoratorExpr, sourceFile));\n    });\n\n    // Ambiguous classes clearly use Angular features, but the migration is unable to\n    // determine whether the class is used as directive, service or pipe. The migration\n    // could potentially determine the type by checking NgModule definitions or inheritance\n    // of other known declarations, but this is out of scope and a TODO/failure is sufficient.\n    return Array.from(ambiguousClasses).reduce((failures, node) => {\n      // If the class has been reported as ambiguous before, skip adding a TODO and\n      // printing an error. A class could be visited multiple times when it's part\n      // of multiple build targets in the CLI project.\n      if (this._hasBeenReportedAsAmbiguous(node)) {\n        return failures;\n      }\n\n      const sourceFile = node.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n\n      // Add a TODO to the class that uses Angular features but is not decorated.\n      recorder.addClassTodo(node, AMBIGUOUS_CLASS_TODO);\n\n      // Add an error for the class that will be printed in the `ng update` output.\n      return failures.concat({\n        node,\n        message: 'Class uses Angular features but cannot be migrated automatically. Please ' +\n            'add an appropriate Angular decorator.'\n      });\n    }, [] as AnalysisFailure[]);\n  }\n\n  /** Records all changes that were made in the import manager. */\n  recordChanges() {\n    this.importManager.recordChanges();\n  }\n\n  /**\n   * Finds undecorated abstract directives in the specified source files. Also returns\n   * a set of undecorated classes which could not be detected as guaranteed abstract\n   * directives. Those are ambiguous and could be either Directive, Pipe or service.\n   */\n  private _findUndecoratedAbstractDirectives(sourceFiles: ts.SourceFile[]) {\n    const ambiguousClasses = new Set<ts.ClassDeclaration>();\n    const declarations = new WeakMap<ts.ClassDeclaration, DeclarationType>();\n    const detectedAbstractDirectives = new Set<ts.ClassDeclaration>();\n    const undecoratedClasses = new Set<ts.ClassDeclaration>();\n\n    const visitNode = (node: ts.Node) => {\n      node.forEachChild(visitNode);\n      if (!ts.isClassDeclaration(node)) {\n        return;\n      }\n      const {inferredKind, decoratedType} = this._analyzeClassDeclaration(node);\n\n      if (decoratedType !== null) {\n        declarations.set(node, decoratedType);\n        return;\n      }\n\n      if (inferredKind === InferredKind.DIRECTIVE) {\n        detectedAbstractDirectives.add(node);\n      } else if (inferredKind === InferredKind.AMBIGUOUS) {\n        ambiguousClasses.add(node);\n      } else {\n        undecoratedClasses.add(node);\n      }\n    };\n\n    sourceFiles.forEach(sourceFile => sourceFile.forEachChild(visitNode));\n\n    /**\n     * Checks the inheritance of the given set of classes. It removes classes from the\n     * detected abstract directives set when they inherit from a non-abstract Angular\n     * declaration. e.g. an abstract directive can never extend from a component.\n     *\n     * If a class inherits from an abstract directive though, we will migrate them too\n     * as derived classes also need to be decorated. This has been done for a simpler mental\n     * model and reduced complexity in the Angular compiler. See migration plan document.\n     */\n    const checkInheritanceOfClasses = (classes: Set<ts.ClassDeclaration>) => {\n      classes.forEach(node => {\n        for (const {node: baseClass} of findBaseClassDeclarations(node, this.typeChecker)) {\n          if (!declarations.has(baseClass)) {\n            continue;\n          }\n          // If the undecorated class inherits from an abstract directive, always migrate it.\n          // Derived undecorated classes of abstract directives are always also considered\n          // abstract directives and need to be decorated too. This is necessary as otherwise\n          // the inheritance chain cannot be resolved by the Angular compiler. e.g. when it\n          // flattens directive metadata for type checking. In the other case, we never want\n          // to migrate a class if it extends from a non-abstract Angular declaration. That\n          // is an unsupported pattern as of v9 and was previously handled with the\n          // `undecorated-classes-with-di` migration (which copied the inherited decorator).\n          if (declarations.get(baseClass) === DeclarationType.ABSTRACT_DIRECTIVE) {\n            detectedAbstractDirectives.add(node);\n          } else {\n            detectedAbstractDirectives.delete(node);\n          }\n          ambiguousClasses.delete(node);\n          break;\n        }\n      });\n    };\n\n    // Check inheritance of any detected abstract directive. We want to remove\n    // classes that are not eligible abstract directives due to inheritance. i.e.\n    // if a class extends from a component, it cannot be a derived abstract directive.\n    checkInheritanceOfClasses(detectedAbstractDirectives);\n    // Update the class declarations to reflect the detected abstract directives. This is\n    // then used later when we check for undecorated classes that inherit from an abstract\n    // directive and need to be decorated.\n    detectedAbstractDirectives.forEach(\n        n => declarations.set(n, DeclarationType.ABSTRACT_DIRECTIVE));\n    // Check ambiguous and undecorated classes if they inherit from an abstract directive.\n    // If they do, we want to migrate them too. See function definition for more details.\n    checkInheritanceOfClasses(ambiguousClasses);\n    checkInheritanceOfClasses(undecoratedClasses);\n\n    return {detectedAbstractDirectives, ambiguousClasses};\n  }\n\n  /**\n   * Analyzes the given class declaration by determining whether the class\n   * is a directive, is an abstract directive, or uses Angular features.\n   */\n  private _analyzeClassDeclaration(node: ts.ClassDeclaration): AnalyzedClass {\n    const ngDecorators = node.decorators && getAngularDecorators(this.typeChecker, node.decorators);\n    const inferredKind = this._determineClassKind(node);\n    if (ngDecorators === undefined || ngDecorators.length === 0) {\n      return {decoratedType: null, inferredKind};\n    }\n    const directiveDecorator = ngDecorators.find(({name}) => name === 'Directive');\n    const componentDecorator = ngDecorators.find(({name}) => name === 'Component');\n    const pipeDecorator = ngDecorators.find(({name}) => name === 'Pipe');\n    const injectableDecorator = ngDecorators.find(({name}) => name === 'Injectable');\n    const isAbstractDirective =\n        directiveDecorator !== undefined && this._isAbstractDirective(directiveDecorator);\n\n    let decoratedType: DeclarationType|null = null;\n    if (isAbstractDirective) {\n      decoratedType = DeclarationType.ABSTRACT_DIRECTIVE;\n    } else if (componentDecorator !== undefined) {\n      decoratedType = DeclarationType.COMPONENT;\n    } else if (directiveDecorator !== undefined) {\n      decoratedType = DeclarationType.DIRECTIVE;\n    } else if (pipeDecorator !== undefined) {\n      decoratedType = DeclarationType.PIPE;\n    } else if (injectableDecorator !== undefined) {\n      decoratedType = DeclarationType.INJECTABLE;\n    }\n    return {decoratedType, inferredKind};\n  }\n\n  /**\n   * Checks whether the given decorator resolves to an abstract directive. An directive is\n   * considered \"abstract\" if there is no selector specified.\n   */\n  private _isAbstractDirective({node}: NgDecorator): boolean {\n    const metadataArgs = node.expression.arguments;\n    if (metadataArgs.length === 0) {\n      return true;\n    }\n    const metadataExpr = unwrapExpression(metadataArgs[0]);\n    if (!ts.isObjectLiteralExpression(metadataExpr)) {\n      return false;\n    }\n    const metadata = reflectObjectLiteral(metadataExpr);\n    if (!metadata.has('selector')) {\n      return false;\n    }\n    const selector = this.partialEvaluator.evaluate(metadata.get('selector')!);\n    return selector == null;\n  }\n\n  /**\n   * Determines the kind of a given class in terms of Angular. The method checks\n   * whether the given class has members that indicate the use of Angular features.\n   * e.g. lifecycle hooks or decorated members like `@Input` or `@Output` are\n   * considered Angular features..\n   */\n  private _determineClassKind(node: ts.ClassDeclaration): InferredKind {\n    let usage = InferredKind.UNKNOWN;\n\n    for (const member of node.members) {\n      const propertyName = member.name !== undefined ? getPropertyNameText(member.name) : null;\n\n      // If the class declares any of the known directive lifecycle hooks, we can\n      // immediately exit the loop as the class is guaranteed to be a directive.\n      if (propertyName !== null && DIRECTIVE_LIFECYCLE_HOOKS.has(propertyName)) {\n        return InferredKind.DIRECTIVE;\n      }\n\n      const ngDecorators = member.decorators !== undefined ?\n          getAngularDecorators(this.typeChecker, member.decorators) :\n          [];\n      for (const {name} of ngDecorators) {\n        if (DIRECTIVE_FIELD_DECORATORS.has(name)) {\n          return InferredKind.DIRECTIVE;\n        }\n      }\n\n      // If the class declares any of the lifecycle hooks that do not guarantee that\n      // the given class is a directive, update the kind and continue looking for other\n      // members that would unveil a more specific kind (i.e. being a directive).\n      if (propertyName !== null && AMBIGUOUS_LIFECYCLE_HOOKS.has(propertyName)) {\n        usage = InferredKind.AMBIGUOUS;\n      }\n    }\n\n    return usage;\n  }\n\n  /**\n   * Checks whether a given class has been reported as ambiguous in previous\n   * migration run. e.g. when build targets are migrated first, and then test\n   * targets that have an overlap with build source files, the same class\n   * could be detected as ambiguous.\n   */\n  private _hasBeenReportedAsAmbiguous(node: ts.ClassDeclaration): boolean {\n    const sourceFile = node.getSourceFile();\n    const leadingComments = ts.getLeadingCommentRanges(sourceFile.text, node.pos);\n    if (leadingComments === undefined) {\n      return false;\n    }\n    return leadingComments.some(\n        ({kind, pos, end}) => kind === ts.SyntaxKind.SingleLineCommentTrivia &&\n            sourceFile.text.substring(pos, end).includes(`TODO: ${AMBIGUOUS_CLASS_TODO}`));\n  }\n}\n"]}

package/src/r3_symbols.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.0.0
+ * @license Angular v10.0.4
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -18,10 +18,13 @@ declare interface AbstractType<T> extends Function {
 }
 
 /**
- * Base class for Angular Views, provides change detection functionality.
+ * Base class that provides change detection functionality.
  * A change-detection tree collects all views that are to be checked for changes.
  * Use the methods to add and remove views from the tree, initiate change-detection,
- * and explicitly mark views as _dirty_, meaning that they have changed and need to be rerendered.
+ * and explicitly mark views as _dirty_, meaning that they have changed and need to be re-rendered.
+ *
+ * @see [Using change detection hooks](guide/lifecycle-hooks#using-change-detection-hooks)
+ * @see [Defining custom change detection](guide/lifecycle-hooks#defining-custom-change-detection)
  *
  * @usageNotes
  *
@@ -691,25 +694,23 @@ declare abstract class NgModuleFactory_2<T> {
 }
 
 /**
- * Represents an instance of an NgModule created via a {@link NgModuleFactory}.
- *
- * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this
- * NgModule Instance.
+ * Represents an instance of an `NgModule` created by an `NgModuleFactory`.
+ * Provides access to the `NgModule` instance and related objects.
  *
  * @publicApi
  */
 declare abstract class NgModuleRef<T> {
     /**
-     * The injector that contains all of the providers of the NgModule.
+     * The injector that contains all of the providers of the `NgModule`.
      */
     abstract get injector(): Injector;
     /**
-     * The ComponentFactoryResolver to get hold of the ComponentFactories
+     * The resolver that can retrieve the component factories
      * declared in the `entryComponents` property of the module.
      */
     abstract get componentFactoryResolver(): ComponentFactoryResolver;
     /**
-     * The NgModule instance.
+     * The `NgModule` instance.
      */
     abstract get instance(): T;
     /**
@@ -717,7 +718,7 @@ declare abstract class NgModuleRef<T> {
      */
     abstract destroy(): void;
     /**
-     * Allows to register a callback that will be called when the module is destroyed.
+     * Registers a callback to be executed when the module is destroyed.
      */
     abstract onDestroy(callback: () => void): void;
 }
@@ -835,7 +836,7 @@ declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProv
  *
  * Represents a type that a Component or other object is instances of.
  *
- * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
  * the `MyCustomComponent` constructor function.
  *
  * @publicApi
@@ -888,12 +889,9 @@ declare interface ValueSansProvider {
 }
 
 /**
- * Represents an Angular [view](guide/glossary#view),
- * specifically the [host view](guide/glossary#view-tree) that is defined by a component.
- * Also serves as the base class
- * that adds destroy methods for [embedded views](guide/glossary#view-tree).
+ * Represents an Angular [view](guide/glossary#view "Definition").
  *
- * @see `EmbeddedViewRef`
+ * @see {@link ChangeDetectorRef#usage-notes Change detection usage}
  *
  * @publicApi
  */

package/testing/testing.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.0.0
+ * @license Angular v10.0.4
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */

package/testing.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.0.0
+ * @license Angular v10.0.4
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */

package/esm2015/src/util/WrappedValue.js

@@ -1,48 +0,0 @@
-/**
- * @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
- */
-/**
- * Indicates that the result of a {@link Pipe} transformation has changed even though the
- * reference has not changed.
- *
- * Wrapped values are unwrapped automatically during the change detection, and the unwrapped value
- * is stored.
- *
- * Example:
- *
- * ```
- * if (this._latestValue === this._latestReturnedValue) {
- *    return this._latestReturnedValue;
- *  } else {
- *    this._latestReturnedValue = this._latestValue;
- *    return WrappedValue.wrap(this._latestValue); // this will force update
- *  }
- * ```
- *
- * @publicApi
- */
-export class WrappedValue {
-    constructor(value) {
-        this.wrapped = value;
-    }
-    /** Creates a wrapped value. */
-    static wrap(value) {
-        return new WrappedValue(value);
-    }
-    /**
-     * Returns the underlying value of a wrapped value.
-     * Returns the given `value` when it is not wrapped.
-     **/
-    static unwrap(value) {
-        return WrappedValue.isWrapped(value) ? value.wrapped : value;
-    }
-    /** Returns true if `value` is a wrapped value. */
-    static isWrapped(value) {
-        return value instanceof WrappedValue;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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