@angular/core 8.0.0-rc.3 → 8.0.1

package/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor.d.ts

@@ -8,6 +8,11 @@
 /// <amd-module name="@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor" />
 import * as ts from 'typescript';
 export declare type FunctionContext = Map<ts.Node, ts.Node>;
+export declare enum ResolvedUsage {
+    SYNCHRONOUS = 0,
+    ASYNCHRONOUS = 1,
+    AMBIGUOUS = 2
+}
 /**
  * Class that can be used to determine if a given TypeScript node is used within
  * other given TypeScript nodes. This is achieved by walking through all children
@@ -20,8 +25,16 @@ export declare class DeclarationUsageVisitor {
     private baseContext;
     /** Set of visited symbols that caused a jump in control flow. */
     private visitedJumpExprNodes;
-    /** Queue of nodes that need to be checked for declaration usage. */
+    /**
+     * Queue of nodes that need to be checked for declaration usage and
+     * are guaranteed to be executed synchronously.
+     */
     private nodeQueue;
+    /**
+     * Nodes which need to be checked for declaration usage but aren't
+     * guaranteed to execute synchronously.
+     */
+    private ambiguousNodeQueue;
     /**
      * Function context that holds the TypeScript node values for all parameters
      * of the currently analyzed function block.
@@ -33,7 +46,16 @@ export declare class DeclarationUsageVisitor {
     private addNewExpressionToQueue;
     private visitPropertyAccessors;
     private visitBinaryExpression;
-    isSynchronouslyUsedInNode(searchNode: ts.Node): boolean;
+    getResolvedNodeUsage(searchNode: ts.Node): ResolvedUsage;
+    private isSynchronouslyUsedInNode;
+    /**
+     * Peeks into the given jump expression by adding all function like declarations
+     * which are referenced in the jump expression arguments to the ambiguous node
+     * queue. These arguments could technically access the given declaration but it's
+     * not guaranteed that the jump expression is executed. In that case the resolved
+     * usage is ambiguous.
+     */
+    private peekIntoJumpExpression;
     /**
      * Resolves a given node from the context. In case the node is not mapped in
      * the context, the original node is returned.
@@ -45,10 +67,11 @@ export declare class DeclarationUsageVisitor {
      */
     private _updateContext;
     /**
-     * Resolves a TypeScript identifier node. For example an identifier can refer to a
-     * function parameter which can be resolved through the function context.
+     * Resolves the declaration of a given TypeScript node. For example an identifier can
+     * refer to a function parameter. This parameter can then be resolved through the
+     * function context.
      */
-    private _resolveIdentifier;
+    private _resolveDeclarationOfNode;
     /**
      * Gets the declaration symbol of a given TypeScript node. Resolves aliased
      * symbols to the symbol containing the value declaration.

package/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor.js

@@ -11,13 +11,20 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/functions"], factory);
+        define("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/functions", "@angular/core/schematics/utils/typescript/property_name"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const ts = require("typescript");
     const functions_1 = require("@angular/core/schematics/utils/typescript/functions");
+    const property_name_1 = require("@angular/core/schematics/utils/typescript/property_name");
+    var ResolvedUsage;
+    (function (ResolvedUsage) {
+        ResolvedUsage[ResolvedUsage["SYNCHRONOUS"] = 0] = "SYNCHRONOUS";
+        ResolvedUsage[ResolvedUsage["ASYNCHRONOUS"] = 1] = "ASYNCHRONOUS";
+        ResolvedUsage[ResolvedUsage["AMBIGUOUS"] = 2] = "AMBIGUOUS";
+    })(ResolvedUsage = exports.ResolvedUsage || (exports.ResolvedUsage = {}));
     /**
      * List of TypeScript syntax tokens that can be used within a binary expression as
      * compound assignment. These imply a read and write of the left-side expression.
@@ -32,6 +39,18 @@
         ts.SyntaxKind.MinusEqualsToken,
         ts.SyntaxKind.SlashEqualsToken,
     ];
+    /**
+     * List of known asynchronous external call expressions which aren't analyzable
+     * but are guaranteed to not execute the passed argument synchronously.
+     */
+    const ASYNC_EXTERNAL_CALLS = [
+        { parent: ['Promise'], name: 'then' },
+        { parent: ['Promise'], name: 'catch' },
+        { parent: [null, 'Window'], name: 'requestAnimationFrame' },
+        { parent: [null, 'Window'], name: 'setTimeout' },
+        { parent: [null, 'Window'], name: 'setInterval' },
+        { parent: ['*'], name: 'addEventListener' },
+    ];
     /**
      * Class that can be used to determine if a given TypeScript node is used within
      * other given TypeScript nodes. This is achieved by walking through all children
@@ -45,8 +64,16 @@
             this.baseContext = baseContext;
             /** Set of visited symbols that caused a jump in control flow. */
             this.visitedJumpExprNodes = new Set();
-            /** Queue of nodes that need to be checked for declaration usage. */
+            /**
+             * Queue of nodes that need to be checked for declaration usage and
+             * are guaranteed to be executed synchronously.
+             */
             this.nodeQueue = [];
+            /**
+             * Nodes which need to be checked for declaration usage but aren't
+             * guaranteed to execute synchronously.
+             */
+            this.ambiguousNodeQueue = [];
             /**
              * Function context that holds the TypeScript node values for all parameters
              * of the currently analyzed function block.
@@ -68,6 +95,7 @@
             }
             const callExprSymbol = this._getDeclarationSymbolOfNode(node);
             if (!callExprSymbol || !callExprSymbol.valueDeclaration) {
+                this.peekIntoJumpExpression(callExpression);
                 return;
             }
             const expressionDecl = this._resolveNodeFromContext(callExprSymbol.valueDeclaration);
@@ -75,6 +103,7 @@
             // this could cause cycles.
             if (!functions_1.isFunctionLikeDeclaration(expressionDecl) ||
                 this.visitedJumpExprNodes.has(expressionDecl) || !expressionDecl.body) {
+                this.peekIntoJumpExpression(callExpression);
                 return;
             }
             // Update the context for the new jump expression and its specified arguments.
@@ -89,6 +118,7 @@
             // we should not visit already visited symbols as this could cause cycles.
             if (!newExprSymbol || !newExprSymbol.valueDeclaration ||
                 !ts.isClassDeclaration(newExprSymbol.valueDeclaration)) {
+                this.peekIntoJumpExpression(node);
                 return;
             }
             const targetConstructor = newExprSymbol.valueDeclaration.members.find(ts.isConstructorDeclaration);
@@ -102,6 +132,9 @@
                 this.visitedJumpExprNodes.add(targetConstructor);
                 this.nodeQueue.push(targetConstructor.body);
             }
+            else {
+                this.peekIntoJumpExpression(node);
+            }
         }
         visitPropertyAccessors(node, checkSetter, checkGetter) {
             const propertySymbol = this._getPropertyAccessSymbol(node);
@@ -142,7 +175,7 @@
             }
             return true;
         }
-        isSynchronouslyUsedInNode(searchNode) {
+        getResolvedNodeUsage(searchNode) {
             this.nodeQueue = [searchNode];
             this.visitedJumpExprNodes.clear();
             this.context.clear();
@@ -151,10 +184,14 @@
             // abstract super class methods are mapped to their implementation node of
             // the derived class.
             this.baseContext.forEach((value, key) => this.context.set(key, value));
+            return this.isSynchronouslyUsedInNode(searchNode);
+        }
+        isSynchronouslyUsedInNode(searchNode) {
+            this.ambiguousNodeQueue = [];
             while (this.nodeQueue.length) {
                 const node = this.nodeQueue.shift();
                 if (ts.isIdentifier(node) && this.isReferringToSymbol(node)) {
-                    return true;
+                    return ResolvedUsage.SYNCHRONOUS;
                 }
                 // Handle call expressions within TypeScript nodes that cause a jump in control
                 // flow. We resolve the call expression value declaration and add it to the node queue.
@@ -192,7 +229,57 @@
                     this.nodeQueue.push(...node.getChildren());
                 }
             }
-            return false;
+            if (this.ambiguousNodeQueue.length) {
+                // Update the node queue to all stored ambiguous nodes. These nodes are not
+                // guaranteed to be executed and therefore in case of a synchronous usage
+                // within one of those nodes, the resolved usage is ambiguous.
+                this.nodeQueue = this.ambiguousNodeQueue;
+                const usage = this.isSynchronouslyUsedInNode(searchNode);
+                return usage === ResolvedUsage.SYNCHRONOUS ? ResolvedUsage.AMBIGUOUS : usage;
+            }
+            return ResolvedUsage.ASYNCHRONOUS;
+        }
+        /**
+         * Peeks into the given jump expression by adding all function like declarations
+         * which are referenced in the jump expression arguments to the ambiguous node
+         * queue. These arguments could technically access the given declaration but it's
+         * not guaranteed that the jump expression is executed. In that case the resolved
+         * usage is ambiguous.
+         */
+        peekIntoJumpExpression(jumpExp) {
+            if (!jumpExp.arguments) {
+                return;
+            }
+            // For some call expressions we don't want to add the arguments to the
+            // ambiguous node queue. e.g. "setTimeout" is not analyzable but is
+            // guaranteed to execute its argument asynchronously. We handle a subset
+            // of these call expressions by having a hardcoded list of some.
+            if (ts.isCallExpression(jumpExp)) {
+                const symbol = this._getDeclarationSymbolOfNode(jumpExp.expression);
+                if (symbol && symbol.valueDeclaration) {
+                    const parentNode = symbol.valueDeclaration.parent;
+                    if (parentNode && (ts.isInterfaceDeclaration(parentNode) || ts.isSourceFile(parentNode)) &&
+                        (ts.isMethodSignature(symbol.valueDeclaration) ||
+                            ts.isFunctionDeclaration(symbol.valueDeclaration)) &&
+                        symbol.valueDeclaration.name) {
+                        const parentName = ts.isInterfaceDeclaration(parentNode) ? parentNode.name.text : null;
+                        const callName = property_name_1.getPropertyNameText(symbol.valueDeclaration.name);
+                        if (ASYNC_EXTERNAL_CALLS.some(c => (c.name === callName &&
+                            (c.parent.indexOf(parentName) !== -1 || c.parent.indexOf('*') !== -1)))) {
+                            return;
+                        }
+                    }
+                }
+            }
+            jumpExp.arguments.forEach((node) => {
+                node = this._resolveDeclarationOfNode(node);
+                if (ts.isVariableDeclaration(node) && node.initializer) {
+                    node = node.initializer;
+                }
+                if (functions_1.isFunctionLikeDeclaration(node) && !!node.body) {
+                    this.ambiguousNodeQueue.push(node.body);
+                }
+            });
         }
         /**
          * Resolves a given node from the context. In case the node is not mapped in
@@ -211,8 +298,16 @@
         _updateContext(callArgs, parameters) {
             parameters.forEach((parameter, index) => {
                 let argumentNode = callArgs[index];
+                if (!argumentNode) {
+                    if (!parameter.initializer) {
+                        return;
+                    }
+                    // Argument can be undefined in case the function parameter has a default
+                    // value. In that case we want to store the parameter default value in the context.
+                    argumentNode = parameter.initializer;
+                }
                 if (ts.isIdentifier(argumentNode)) {
-                    this.context.set(parameter, this._resolveIdentifier(argumentNode));
+                    this.context.set(parameter, this._resolveDeclarationOfNode(argumentNode));
                 }
                 else {
                     this.context.set(parameter, argumentNode);
@@ -220,10 +315,11 @@
             });
         }
         /**
-         * Resolves a TypeScript identifier node. For example an identifier can refer to a
-         * function parameter which can be resolved through the function context.
+         * Resolves the declaration of a given TypeScript node. For example an identifier can
+         * refer to a function parameter. This parameter can then be resolved through the
+         * function context.
          */
-        _resolveIdentifier(node) {
+        _resolveDeclarationOfNode(node) {
             const symbol = this._getDeclarationSymbolOfNode(node);
             if (!symbol || !symbol.valueDeclaration) {
                 return node;
@@ -248,7 +344,7 @@
         /** Gets the symbol of the given property access expression. */
         _getPropertyAccessSymbol(node) {
             let propertySymbol = this._getDeclarationSymbolOfNode(node.name);
-            if (!propertySymbol) {
+            if (!propertySymbol || !propertySymbol.valueDeclaration) {
                 return null;
             }
             if (!this.context.has(propertySymbol.valueDeclaration)) {
@@ -269,4 +365,4 @@
     }
     exports.DeclarationUsageVisitor = DeclarationUsageVisitor;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"declaration_usage_visitor.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor.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 * as ts from 'typescript';\nimport {isFunctionLikeDeclaration, unwrapExpression} from '../../../../utils/typescript/functions';\n\nexport type FunctionContext = Map<ts.Node, ts.Node>;\n\n/**\n * List of TypeScript syntax tokens that can be used within a binary expression as\n * compound assignment. These imply a read and write of the left-side expression.\n */\nconst BINARY_COMPOUND_TOKENS = [\n  ts.SyntaxKind.CaretEqualsToken,\n  ts.SyntaxKind.AsteriskEqualsToken,\n  ts.SyntaxKind.AmpersandEqualsToken,\n  ts.SyntaxKind.BarEqualsToken,\n  ts.SyntaxKind.AsteriskAsteriskEqualsToken,\n  ts.SyntaxKind.PlusEqualsToken,\n  ts.SyntaxKind.MinusEqualsToken,\n  ts.SyntaxKind.SlashEqualsToken,\n];\n\n/**\n * Class that can be used to determine if a given TypeScript node is used within\n * other given TypeScript nodes. This is achieved by walking through all children\n * of the given node and checking for usages of the given declaration. The visitor\n * also handles potential control flow changes caused by call/new expressions.\n */\nexport class DeclarationUsageVisitor {\n  /** Set of visited symbols that caused a jump in control flow. */\n  private visitedJumpExprNodes = new Set<ts.Node>();\n\n  /** Queue of nodes that need to be checked for declaration usage. */\n  private nodeQueue: ts.Node[] = [];\n\n  /**\n   * Function context that holds the TypeScript node values for all parameters\n   * of the currently analyzed function block.\n   */\n  private context: FunctionContext = new Map();\n\n  constructor(\n      private declaration: ts.Node, private typeChecker: ts.TypeChecker,\n      private baseContext: FunctionContext = new Map()) {}\n\n  private isReferringToSymbol(node: ts.Node): boolean {\n    const symbol = this.typeChecker.getSymbolAtLocation(node);\n    return !!symbol && symbol.valueDeclaration === this.declaration;\n  }\n\n  private addJumpExpressionToQueue(callExpression: ts.CallExpression) {\n    const node = unwrapExpression(callExpression.expression);\n\n    // In case the given expression is already referring to a function-like declaration,\n    // we don't need to resolve the symbol of the expression as the jump expression is\n    // defined inline and we can just add the given node to the queue.\n    if (isFunctionLikeDeclaration(node) && node.body) {\n      this.nodeQueue.push(node.body);\n      return;\n    }\n\n    const callExprSymbol = this._getDeclarationSymbolOfNode(node);\n\n    if (!callExprSymbol || !callExprSymbol.valueDeclaration) {\n      return;\n    }\n\n    const expressionDecl = this._resolveNodeFromContext(callExprSymbol.valueDeclaration);\n\n    // Note that we should not add previously visited symbols to the queue as\n    // this could cause cycles.\n    if (!isFunctionLikeDeclaration(expressionDecl) ||\n        this.visitedJumpExprNodes.has(expressionDecl) || !expressionDecl.body) {\n      return;\n    }\n\n    // Update the context for the new jump expression and its specified arguments.\n    this._updateContext(callExpression.arguments, expressionDecl.parameters);\n\n    this.visitedJumpExprNodes.add(expressionDecl);\n    this.nodeQueue.push(expressionDecl.body);\n  }\n\n  private addNewExpressionToQueue(node: ts.NewExpression) {\n    const newExprSymbol = this._getDeclarationSymbolOfNode(unwrapExpression(node.expression));\n\n    // Only handle new expressions which resolve to classes. Technically \"new\" could\n    // also call void functions or objects with a constructor signature. Also note that\n    // we should not visit already visited symbols as this could cause cycles.\n    if (!newExprSymbol || !newExprSymbol.valueDeclaration ||\n        !ts.isClassDeclaration(newExprSymbol.valueDeclaration)) {\n      return;\n    }\n\n    const targetConstructor =\n        newExprSymbol.valueDeclaration.members.find(ts.isConstructorDeclaration);\n\n    if (targetConstructor && targetConstructor.body &&\n        !this.visitedJumpExprNodes.has(targetConstructor)) {\n      // Update the context for the new expression and its specified constructor\n      // parameters if arguments are passed to the class constructor.\n      if (node.arguments) {\n        this._updateContext(node.arguments, targetConstructor.parameters);\n      }\n\n      this.visitedJumpExprNodes.add(targetConstructor);\n      this.nodeQueue.push(targetConstructor.body);\n    }\n  }\n\n  private visitPropertyAccessors(\n      node: ts.PropertyAccessExpression, checkSetter: boolean, checkGetter: boolean) {\n    const propertySymbol = this._getPropertyAccessSymbol(node);\n\n    if (!propertySymbol || !propertySymbol.declarations.length ||\n        (propertySymbol.getFlags() & ts.SymbolFlags.Accessor) === 0) {\n      return;\n    }\n\n    // Since we checked the symbol flags and the symbol is describing an accessor, the\n    // declarations are guaranteed to only contain the getters and setters.\n    const accessors = propertySymbol.declarations as ts.AccessorDeclaration[];\n\n    accessors\n        .filter(\n            d => (checkSetter && ts.isSetAccessor(d) || checkGetter && ts.isGetAccessor(d)) &&\n                d.body && !this.visitedJumpExprNodes.has(d))\n        .forEach(d => {\n          this.visitedJumpExprNodes.add(d);\n          this.nodeQueue.push(d.body !);\n        });\n  }\n\n  private visitBinaryExpression(node: ts.BinaryExpression): boolean {\n    const leftExpr = unwrapExpression(node.left);\n\n    if (!ts.isPropertyAccessExpression(leftExpr)) {\n      return false;\n    }\n\n    if (BINARY_COMPOUND_TOKENS.indexOf(node.operatorToken.kind) !== -1) {\n      // Compound assignments always cause the getter and setter to be called.\n      // Therefore we need to check the setter and getter of the property access.\n      this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ true);\n    } else if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n      // Value assignments using the equals token only cause the \"setter\" to be called.\n      // Therefore we need to analyze the setter declaration of the property access.\n      this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ false);\n    } else {\n      // If the binary expression is not an assignment, it's a simple property read and\n      // we need to check the getter declaration if present.\n      this.visitPropertyAccessors(leftExpr, /* setter */ false, /* getter */ true);\n    }\n    return true;\n  }\n\n  isSynchronouslyUsedInNode(searchNode: ts.Node): boolean {\n    this.nodeQueue = [searchNode];\n    this.visitedJumpExprNodes.clear();\n    this.context.clear();\n\n    // Copy base context values into the current function block context. The\n    // base context is useful if nodes need to be mapped to other nodes. e.g.\n    // abstract super class methods are mapped to their implementation node of\n    // the derived class.\n    this.baseContext.forEach((value, key) => this.context.set(key, value));\n\n    while (this.nodeQueue.length) {\n      const node = this.nodeQueue.shift() !;\n\n      if (ts.isIdentifier(node) && this.isReferringToSymbol(node)) {\n        return true;\n      }\n\n      // Handle call expressions within TypeScript nodes that cause a jump in control\n      // flow. We resolve the call expression value declaration and add it to the node queue.\n      if (ts.isCallExpression(node)) {\n        this.addJumpExpressionToQueue(node);\n      }\n\n      // Handle new expressions that cause a jump in control flow. We resolve the\n      // constructor declaration of the target class and add it to the node queue.\n      if (ts.isNewExpression(node)) {\n        this.addNewExpressionToQueue(node);\n      }\n\n      // We also need to handle binary expressions where a value can be either assigned to\n      // the property, or a value is read from a property expression. Depending on the\n      // binary expression operator, setters or getters need to be analyzed.\n      if (ts.isBinaryExpression(node)) {\n        // In case the binary expression contained a property expression on the left side, we\n        // don't want to continue visiting this property expression on its own. This is necessary\n        // because visiting the expression on its own causes a loss of context. e.g. property\n        // access expressions *do not* always cause a value read (e.g. property assignments)\n        if (this.visitBinaryExpression(node)) {\n          this.nodeQueue.push(node.right);\n          continue;\n        }\n      }\n\n      // Handle property access expressions. Property expressions which are part of binary\n      // expressions won't be added to the node queue, so these access expressions are\n      // guaranteed to be \"read\" accesses and we need to check the \"getter\" declaration.\n      if (ts.isPropertyAccessExpression(node)) {\n        this.visitPropertyAccessors(node, /* setter */ false, /* getter */ true);\n      }\n\n      // Do not visit nodes that declare a block of statements but are not executed\n      // synchronously (e.g. function declarations). We only want to check TypeScript\n      // nodes which are synchronously executed in the control flow.\n      if (!isFunctionLikeDeclaration(node)) {\n        this.nodeQueue.push(...node.getChildren());\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Resolves a given node from the context. In case the node is not mapped in\n   * the context, the original node is returned.\n   */\n  private _resolveNodeFromContext(node: ts.Node): ts.Node {\n    if (this.context.has(node)) {\n      return this.context.get(node) !;\n    }\n    return node;\n  }\n\n  /**\n   * Updates the context to reflect the newly set parameter values. This allows future\n   * references to function parameters to be resolved to the actual node through the context.\n   */\n  private _updateContext(\n      callArgs: ts.NodeArray<ts.Expression>, parameters: ts.NodeArray<ts.ParameterDeclaration>) {\n    parameters.forEach((parameter, index) => {\n      let argumentNode: ts.Node = callArgs[index];\n      if (ts.isIdentifier(argumentNode)) {\n        this.context.set(parameter, this._resolveIdentifier(argumentNode));\n      } else {\n        this.context.set(parameter, argumentNode);\n      }\n    });\n  }\n\n  /**\n   * Resolves a TypeScript identifier node. For example an identifier can refer to a\n   * function parameter which can be resolved through the function context.\n   */\n  private _resolveIdentifier(node: ts.Identifier): ts.Node {\n    const symbol = this._getDeclarationSymbolOfNode(node);\n\n    if (!symbol || !symbol.valueDeclaration) {\n      return node;\n    }\n\n    return this._resolveNodeFromContext(symbol.valueDeclaration);\n  }\n\n  /**\n   * Gets the declaration symbol of a given TypeScript node. Resolves aliased\n   * symbols to the symbol containing the value declaration.\n   */\n  private _getDeclarationSymbolOfNode(node: ts.Node): ts.Symbol|null {\n    let symbol = this.typeChecker.getSymbolAtLocation(node);\n\n    if (!symbol) {\n      return null;\n    }\n\n    // Resolve the symbol to it's original declaration symbol.\n    while (symbol.flags & ts.SymbolFlags.Alias) {\n      symbol = this.typeChecker.getAliasedSymbol(symbol);\n    }\n\n    return symbol;\n  }\n\n  /** Gets the symbol of the given property access expression. */\n  private _getPropertyAccessSymbol(node: ts.PropertyAccessExpression): ts.Symbol|null {\n    let propertySymbol = this._getDeclarationSymbolOfNode(node.name);\n\n    if (!propertySymbol) {\n      return null;\n    }\n\n    if (!this.context.has(propertySymbol.valueDeclaration)) {\n      return propertySymbol;\n    }\n\n    // In case the context has the value declaration of the given property access\n    // name identifier, we need to replace the \"propertySymbol\" with the symbol\n    // referring to the resolved symbol based on the context. e.g. abstract properties\n    // can ultimately resolve into an accessor declaration based on the implementation.\n    const contextNode = this._resolveNodeFromContext(propertySymbol.valueDeclaration);\n\n    if (!ts.isAccessor(contextNode)) {\n      return null;\n    }\n\n    // Resolve the symbol referring to the \"accessor\" using the name identifier\n    // of the accessor declaration.\n    return this._getDeclarationSymbolOfNode(contextNode.name);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"declaration_usage_visitor.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor.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 * as ts from 'typescript';\nimport {isFunctionLikeDeclaration, unwrapExpression} from '../../../../utils/typescript/functions';\nimport {getPropertyNameText} from '../../../../utils/typescript/property_name';\n\nexport type FunctionContext = Map<ts.Node, ts.Node>;\n\nexport enum ResolvedUsage {\n  SYNCHRONOUS,\n  ASYNCHRONOUS,\n  AMBIGUOUS,\n}\n\n/**\n * List of TypeScript syntax tokens that can be used within a binary expression as\n * compound assignment. These imply a read and write of the left-side expression.\n */\nconst BINARY_COMPOUND_TOKENS = [\n  ts.SyntaxKind.CaretEqualsToken,\n  ts.SyntaxKind.AsteriskEqualsToken,\n  ts.SyntaxKind.AmpersandEqualsToken,\n  ts.SyntaxKind.BarEqualsToken,\n  ts.SyntaxKind.AsteriskAsteriskEqualsToken,\n  ts.SyntaxKind.PlusEqualsToken,\n  ts.SyntaxKind.MinusEqualsToken,\n  ts.SyntaxKind.SlashEqualsToken,\n];\n\n/**\n * List of known asynchronous external call expressions which aren't analyzable\n * but are guaranteed to not execute the passed argument synchronously.\n */\nconst ASYNC_EXTERNAL_CALLS = [\n  {parent: ['Promise'], name: 'then'},\n  {parent: ['Promise'], name: 'catch'},\n  {parent: [null, 'Window'], name: 'requestAnimationFrame'},\n  {parent: [null, 'Window'], name: 'setTimeout'},\n  {parent: [null, 'Window'], name: 'setInterval'},\n  {parent: ['*'], name: 'addEventListener'},\n];\n\n/**\n * Class that can be used to determine if a given TypeScript node is used within\n * other given TypeScript nodes. This is achieved by walking through all children\n * of the given node and checking for usages of the given declaration. The visitor\n * also handles potential control flow changes caused by call/new expressions.\n */\nexport class DeclarationUsageVisitor {\n  /** Set of visited symbols that caused a jump in control flow. */\n  private visitedJumpExprNodes = new Set<ts.Node>();\n\n  /**\n   * Queue of nodes that need to be checked for declaration usage and\n   * are guaranteed to be executed synchronously.\n   */\n  private nodeQueue: ts.Node[] = [];\n\n  /**\n   * Nodes which need to be checked for declaration usage but aren't\n   * guaranteed to execute synchronously.\n   */\n  private ambiguousNodeQueue: ts.Node[] = [];\n\n  /**\n   * Function context that holds the TypeScript node values for all parameters\n   * of the currently analyzed function block.\n   */\n  private context: FunctionContext = new Map();\n\n  constructor(\n      private declaration: ts.Node, private typeChecker: ts.TypeChecker,\n      private baseContext: FunctionContext = new Map()) {}\n\n  private isReferringToSymbol(node: ts.Node): boolean {\n    const symbol = this.typeChecker.getSymbolAtLocation(node);\n    return !!symbol && symbol.valueDeclaration === this.declaration;\n  }\n\n  private addJumpExpressionToQueue(callExpression: ts.CallExpression) {\n    const node = unwrapExpression(callExpression.expression);\n\n    // In case the given expression is already referring to a function-like declaration,\n    // we don't need to resolve the symbol of the expression as the jump expression is\n    // defined inline and we can just add the given node to the queue.\n    if (isFunctionLikeDeclaration(node) && node.body) {\n      this.nodeQueue.push(node.body);\n      return;\n    }\n\n    const callExprSymbol = this._getDeclarationSymbolOfNode(node);\n\n    if (!callExprSymbol || !callExprSymbol.valueDeclaration) {\n      this.peekIntoJumpExpression(callExpression);\n      return;\n    }\n\n    const expressionDecl = this._resolveNodeFromContext(callExprSymbol.valueDeclaration);\n\n    // Note that we should not add previously visited symbols to the queue as\n    // this could cause cycles.\n    if (!isFunctionLikeDeclaration(expressionDecl) ||\n        this.visitedJumpExprNodes.has(expressionDecl) || !expressionDecl.body) {\n      this.peekIntoJumpExpression(callExpression);\n      return;\n    }\n\n    // Update the context for the new jump expression and its specified arguments.\n    this._updateContext(callExpression.arguments, expressionDecl.parameters);\n\n    this.visitedJumpExprNodes.add(expressionDecl);\n    this.nodeQueue.push(expressionDecl.body);\n  }\n\n  private addNewExpressionToQueue(node: ts.NewExpression) {\n    const newExprSymbol = this._getDeclarationSymbolOfNode(unwrapExpression(node.expression));\n\n    // Only handle new expressions which resolve to classes. Technically \"new\" could\n    // also call void functions or objects with a constructor signature. Also note that\n    // we should not visit already visited symbols as this could cause cycles.\n    if (!newExprSymbol || !newExprSymbol.valueDeclaration ||\n        !ts.isClassDeclaration(newExprSymbol.valueDeclaration)) {\n      this.peekIntoJumpExpression(node);\n      return;\n    }\n\n    const targetConstructor =\n        newExprSymbol.valueDeclaration.members.find(ts.isConstructorDeclaration);\n\n    if (targetConstructor && targetConstructor.body &&\n        !this.visitedJumpExprNodes.has(targetConstructor)) {\n      // Update the context for the new expression and its specified constructor\n      // parameters if arguments are passed to the class constructor.\n      if (node.arguments) {\n        this._updateContext(node.arguments, targetConstructor.parameters);\n      }\n\n      this.visitedJumpExprNodes.add(targetConstructor);\n      this.nodeQueue.push(targetConstructor.body);\n    } else {\n      this.peekIntoJumpExpression(node);\n    }\n  }\n\n  private visitPropertyAccessors(\n      node: ts.PropertyAccessExpression, checkSetter: boolean, checkGetter: boolean) {\n    const propertySymbol = this._getPropertyAccessSymbol(node);\n\n    if (!propertySymbol || !propertySymbol.declarations.length ||\n        (propertySymbol.getFlags() & ts.SymbolFlags.Accessor) === 0) {\n      return;\n    }\n\n    // Since we checked the symbol flags and the symbol is describing an accessor, the\n    // declarations are guaranteed to only contain the getters and setters.\n    const accessors = propertySymbol.declarations as ts.AccessorDeclaration[];\n\n    accessors\n        .filter(\n            d => (checkSetter && ts.isSetAccessor(d) || checkGetter && ts.isGetAccessor(d)) &&\n                d.body && !this.visitedJumpExprNodes.has(d))\n        .forEach(d => {\n          this.visitedJumpExprNodes.add(d);\n          this.nodeQueue.push(d.body !);\n        });\n  }\n\n  private visitBinaryExpression(node: ts.BinaryExpression): boolean {\n    const leftExpr = unwrapExpression(node.left);\n\n    if (!ts.isPropertyAccessExpression(leftExpr)) {\n      return false;\n    }\n\n    if (BINARY_COMPOUND_TOKENS.indexOf(node.operatorToken.kind) !== -1) {\n      // Compound assignments always cause the getter and setter to be called.\n      // Therefore we need to check the setter and getter of the property access.\n      this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ true);\n    } else if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n      // Value assignments using the equals token only cause the \"setter\" to be called.\n      // Therefore we need to analyze the setter declaration of the property access.\n      this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ false);\n    } else {\n      // If the binary expression is not an assignment, it's a simple property read and\n      // we need to check the getter declaration if present.\n      this.visitPropertyAccessors(leftExpr, /* setter */ false, /* getter */ true);\n    }\n    return true;\n  }\n\n  getResolvedNodeUsage(searchNode: ts.Node): ResolvedUsage {\n    this.nodeQueue = [searchNode];\n    this.visitedJumpExprNodes.clear();\n    this.context.clear();\n\n    // Copy base context values into the current function block context. The\n    // base context is useful if nodes need to be mapped to other nodes. e.g.\n    // abstract super class methods are mapped to their implementation node of\n    // the derived class.\n    this.baseContext.forEach((value, key) => this.context.set(key, value));\n\n    return this.isSynchronouslyUsedInNode(searchNode);\n  }\n\n  private isSynchronouslyUsedInNode(searchNode: ts.Node): ResolvedUsage {\n    this.ambiguousNodeQueue = [];\n\n    while (this.nodeQueue.length) {\n      const node = this.nodeQueue.shift() !;\n\n      if (ts.isIdentifier(node) && this.isReferringToSymbol(node)) {\n        return ResolvedUsage.SYNCHRONOUS;\n      }\n\n      // Handle call expressions within TypeScript nodes that cause a jump in control\n      // flow. We resolve the call expression value declaration and add it to the node queue.\n      if (ts.isCallExpression(node)) {\n        this.addJumpExpressionToQueue(node);\n      }\n\n      // Handle new expressions that cause a jump in control flow. We resolve the\n      // constructor declaration of the target class and add it to the node queue.\n      if (ts.isNewExpression(node)) {\n        this.addNewExpressionToQueue(node);\n      }\n\n      // We also need to handle binary expressions where a value can be either assigned to\n      // the property, or a value is read from a property expression. Depending on the\n      // binary expression operator, setters or getters need to be analyzed.\n      if (ts.isBinaryExpression(node)) {\n        // In case the binary expression contained a property expression on the left side, we\n        // don't want to continue visiting this property expression on its own. This is necessary\n        // because visiting the expression on its own causes a loss of context. e.g. property\n        // access expressions *do not* always cause a value read (e.g. property assignments)\n        if (this.visitBinaryExpression(node)) {\n          this.nodeQueue.push(node.right);\n          continue;\n        }\n      }\n\n      // Handle property access expressions. Property expressions which are part of binary\n      // expressions won't be added to the node queue, so these access expressions are\n      // guaranteed to be \"read\" accesses and we need to check the \"getter\" declaration.\n      if (ts.isPropertyAccessExpression(node)) {\n        this.visitPropertyAccessors(node, /* setter */ false, /* getter */ true);\n      }\n\n      // Do not visit nodes that declare a block of statements but are not executed\n      // synchronously (e.g. function declarations). We only want to check TypeScript\n      // nodes which are synchronously executed in the control flow.\n      if (!isFunctionLikeDeclaration(node)) {\n        this.nodeQueue.push(...node.getChildren());\n      }\n    }\n\n    if (this.ambiguousNodeQueue.length) {\n      // Update the node queue to all stored ambiguous nodes. These nodes are not\n      // guaranteed to be executed and therefore in case of a synchronous usage\n      // within one of those nodes, the resolved usage is ambiguous.\n      this.nodeQueue = this.ambiguousNodeQueue;\n      const usage = this.isSynchronouslyUsedInNode(searchNode);\n      return usage === ResolvedUsage.SYNCHRONOUS ? ResolvedUsage.AMBIGUOUS : usage;\n    }\n    return ResolvedUsage.ASYNCHRONOUS;\n  }\n\n  /**\n   * Peeks into the given jump expression by adding all function like declarations\n   * which are referenced in the jump expression arguments to the ambiguous node\n   * queue. These arguments could technically access the given declaration but it's\n   * not guaranteed that the jump expression is executed. In that case the resolved\n   * usage is ambiguous.\n   */\n  private peekIntoJumpExpression(jumpExp: ts.CallExpression|ts.NewExpression) {\n    if (!jumpExp.arguments) {\n      return;\n    }\n\n    // For some call expressions we don't want to add the arguments to the\n    // ambiguous node queue. e.g. \"setTimeout\" is not analyzable but is\n    // guaranteed to execute its argument asynchronously. We handle a subset\n    // of these call expressions by having a hardcoded list of some.\n    if (ts.isCallExpression(jumpExp)) {\n      const symbol = this._getDeclarationSymbolOfNode(jumpExp.expression);\n      if (symbol && symbol.valueDeclaration) {\n        const parentNode = symbol.valueDeclaration.parent;\n        if (parentNode && (ts.isInterfaceDeclaration(parentNode) || ts.isSourceFile(parentNode)) &&\n            (ts.isMethodSignature(symbol.valueDeclaration) ||\n             ts.isFunctionDeclaration(symbol.valueDeclaration)) &&\n            symbol.valueDeclaration.name) {\n          const parentName = ts.isInterfaceDeclaration(parentNode) ? parentNode.name.text : null;\n          const callName = getPropertyNameText(symbol.valueDeclaration.name);\n          if (ASYNC_EXTERNAL_CALLS.some(\n                  c =>\n                      (c.name === callName &&\n                       (c.parent.indexOf(parentName) !== -1 || c.parent.indexOf('*') !== -1)))) {\n            return;\n          }\n        }\n      }\n    }\n\n    jumpExp.arguments !.forEach((node: ts.Node) => {\n      node = this._resolveDeclarationOfNode(node);\n\n      if (ts.isVariableDeclaration(node) && node.initializer) {\n        node = node.initializer;\n      }\n\n      if (isFunctionLikeDeclaration(node) && !!node.body) {\n        this.ambiguousNodeQueue.push(node.body);\n      }\n    });\n  }\n\n  /**\n   * Resolves a given node from the context. In case the node is not mapped in\n   * the context, the original node is returned.\n   */\n  private _resolveNodeFromContext(node: ts.Node): ts.Node {\n    if (this.context.has(node)) {\n      return this.context.get(node) !;\n    }\n    return node;\n  }\n\n  /**\n   * Updates the context to reflect the newly set parameter values. This allows future\n   * references to function parameters to be resolved to the actual node through the context.\n   */\n  private _updateContext(\n      callArgs: ts.NodeArray<ts.Expression>, parameters: ts.NodeArray<ts.ParameterDeclaration>) {\n    parameters.forEach((parameter, index) => {\n      let argumentNode: ts.Node = callArgs[index];\n\n      if (!argumentNode) {\n        if (!parameter.initializer) {\n          return;\n        }\n\n        // Argument can be undefined in case the function parameter has a default\n        // value. In that case we want to store the parameter default value in the context.\n        argumentNode = parameter.initializer;\n      }\n\n      if (ts.isIdentifier(argumentNode)) {\n        this.context.set(parameter, this._resolveDeclarationOfNode(argumentNode));\n      } else {\n        this.context.set(parameter, argumentNode);\n      }\n    });\n  }\n\n  /**\n   * Resolves the declaration of a given TypeScript node. For example an identifier can\n   * refer to a function parameter. This parameter can then be resolved through the\n   * function context.\n   */\n  private _resolveDeclarationOfNode(node: ts.Node): ts.Node {\n    const symbol = this._getDeclarationSymbolOfNode(node);\n\n    if (!symbol || !symbol.valueDeclaration) {\n      return node;\n    }\n\n    return this._resolveNodeFromContext(symbol.valueDeclaration);\n  }\n\n  /**\n   * Gets the declaration symbol of a given TypeScript node. Resolves aliased\n   * symbols to the symbol containing the value declaration.\n   */\n  private _getDeclarationSymbolOfNode(node: ts.Node): ts.Symbol|null {\n    let symbol = this.typeChecker.getSymbolAtLocation(node);\n\n    if (!symbol) {\n      return null;\n    }\n\n    // Resolve the symbol to it's original declaration symbol.\n    while (symbol.flags & ts.SymbolFlags.Alias) {\n      symbol = this.typeChecker.getAliasedSymbol(symbol);\n    }\n\n    return symbol;\n  }\n\n  /** Gets the symbol of the given property access expression. */\n  private _getPropertyAccessSymbol(node: ts.PropertyAccessExpression): ts.Symbol|null {\n    let propertySymbol = this._getDeclarationSymbolOfNode(node.name);\n\n    if (!propertySymbol || !propertySymbol.valueDeclaration) {\n      return null;\n    }\n\n    if (!this.context.has(propertySymbol.valueDeclaration)) {\n      return propertySymbol;\n    }\n\n    // In case the context has the value declaration of the given property access\n    // name identifier, we need to replace the \"propertySymbol\" with the symbol\n    // referring to the resolved symbol based on the context. e.g. abstract properties\n    // can ultimately resolve into an accessor declaration based on the implementation.\n    const contextNode = this._resolveNodeFromContext(propertySymbol.valueDeclaration);\n\n    if (!ts.isAccessor(contextNode)) {\n      return null;\n    }\n\n    // Resolve the symbol referring to the \"accessor\" using the name identifier\n    // of the accessor declaration.\n    return this._getDeclarationSymbolOfNode(contextNode.name);\n  }\n}\n"]}

package/schematics/migrations/static-queries/strategies/usage_strategy/usage_strategy.d.ts

@@ -19,10 +19,15 @@ export declare class QueryUsageStrategy implements TimingStrategy {
     private classMetadata;
     private typeChecker;
     constructor(classMetadata: ClassMetadataMap, typeChecker: ts.TypeChecker);
-    setup(): boolean;
+    setup(): void;
     /**
      * Analyzes the usage of the given query and determines the query timing based
      * on the current usage of the query.
      */
     detectTiming(query: NgQueryDefinition): TimingResult;
+    /**
+     * Checks whether a given query is used statically within the given class, its super
+     * class or derived classes.
+     */
+    private analyzeQueryUsage;
 }