@angular/core 12.1.1 → 12.1.2

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

@@ -1,355 +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
- */
-import * as ts from 'typescript';
-import { isFunctionLikeDeclaration, unwrapExpression } from '../../../../utils/typescript/functions';
-import { getPropertyNameText } from '../../../../utils/typescript/property_name';
-export var ResolvedUsage;
-(function (ResolvedUsage) {
-    ResolvedUsage[ResolvedUsage["SYNCHRONOUS"] = 0] = "SYNCHRONOUS";
-    ResolvedUsage[ResolvedUsage["ASYNCHRONOUS"] = 1] = "ASYNCHRONOUS";
-    ResolvedUsage[ResolvedUsage["AMBIGUOUS"] = 2] = "AMBIGUOUS";
-})(ResolvedUsage || (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.
- */
-const BINARY_COMPOUND_TOKENS = [
-    ts.SyntaxKind.CaretEqualsToken,
-    ts.SyntaxKind.AsteriskEqualsToken,
-    ts.SyntaxKind.AmpersandEqualsToken,
-    ts.SyntaxKind.BarEqualsToken,
-    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
-    ts.SyntaxKind.PlusEqualsToken,
-    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
- * of the given node and checking for usages of the given declaration. The visitor
- * also handles potential control flow changes caused by call/new expressions.
- */
-export class DeclarationUsageVisitor {
-    constructor(declaration, typeChecker, baseContext = new Map()) {
-        this.declaration = declaration;
-        this.typeChecker = typeChecker;
-        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 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.
-         */
-        this.context = new Map();
-    }
-    isReferringToSymbol(node) {
-        const symbol = this.typeChecker.getSymbolAtLocation(node);
-        return !!symbol && symbol.valueDeclaration === this.declaration;
-    }
-    addJumpExpressionToQueue(callExpression) {
-        const node = unwrapExpression(callExpression.expression);
-        // In case the given expression is already referring to a function-like declaration,
-        // we don't need to resolve the symbol of the expression as the jump expression is
-        // defined inline and we can just add the given node to the queue.
-        if (isFunctionLikeDeclaration(node) && node.body) {
-            this.nodeQueue.push(node.body);
-            return;
-        }
-        const callExprSymbol = this._getDeclarationSymbolOfNode(node);
-        if (!callExprSymbol || !callExprSymbol.valueDeclaration) {
-            this.peekIntoJumpExpression(callExpression);
-            return;
-        }
-        const expressionDecl = this._resolveNodeFromContext(callExprSymbol.valueDeclaration);
-        // Note that we should not add previously visited symbols to the queue as
-        // this could cause cycles.
-        if (!isFunctionLikeDeclaration(expressionDecl) ||
-            this.visitedJumpExprNodes.has(expressionDecl) || !expressionDecl.body) {
-            this.peekIntoJumpExpression(callExpression);
-            return;
-        }
-        // Update the context for the new jump expression and its specified arguments.
-        this._updateContext(callExpression.arguments, expressionDecl.parameters);
-        this.visitedJumpExprNodes.add(expressionDecl);
-        this.nodeQueue.push(expressionDecl.body);
-    }
-    addNewExpressionToQueue(node) {
-        const newExprSymbol = this._getDeclarationSymbolOfNode(unwrapExpression(node.expression));
-        // Only handle new expressions which resolve to classes. Technically "new" could
-        // also call void functions or objects with a constructor signature. Also note that
-        // 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);
-        if (targetConstructor && targetConstructor.body &&
-            !this.visitedJumpExprNodes.has(targetConstructor)) {
-            // Update the context for the new expression and its specified constructor
-            // parameters if arguments are passed to the class constructor.
-            if (node.arguments) {
-                this._updateContext(node.arguments, targetConstructor.parameters);
-            }
-            this.visitedJumpExprNodes.add(targetConstructor);
-            this.nodeQueue.push(targetConstructor.body);
-        }
-        else {
-            this.peekIntoJumpExpression(node);
-        }
-    }
-    visitPropertyAccessors(node, checkSetter, checkGetter) {
-        const propertySymbol = this._getPropertyAccessSymbol(node);
-        if ((propertySymbol === null || propertySymbol === void 0 ? void 0 : propertySymbol.declarations) === undefined || propertySymbol.declarations.length === 0 ||
-            (propertySymbol.getFlags() & ts.SymbolFlags.Accessor) === 0) {
-            return;
-        }
-        // Since we checked the symbol flags and the symbol is describing an accessor, the
-        // declarations are guaranteed to only contain the getters and setters.
-        const accessors = propertySymbol.declarations;
-        accessors
-            .filter(d => (checkSetter && ts.isSetAccessor(d) || checkGetter && ts.isGetAccessor(d)) &&
-            d.body && !this.visitedJumpExprNodes.has(d))
-            .forEach(d => {
-            this.visitedJumpExprNodes.add(d);
-            this.nodeQueue.push(d.body);
-        });
-    }
-    visitBinaryExpression(node) {
-        const leftExpr = unwrapExpression(node.left);
-        if (!ts.isPropertyAccessExpression(leftExpr)) {
-            return false;
-        }
-        if (BINARY_COMPOUND_TOKENS.indexOf(node.operatorToken.kind) !== -1) {
-            // Compound assignments always cause the getter and setter to be called.
-            // Therefore we need to check the setter and getter of the property access.
-            this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ true);
-        }
-        else if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-            // Value assignments using the equals token only cause the "setter" to be called.
-            // Therefore we need to analyze the setter declaration of the property access.
-            this.visitPropertyAccessors(leftExpr, /* setter */ true, /* getter */ false);
-        }
-        else {
-            // If the binary expression is not an assignment, it's a simple property read and
-            // we need to check the getter declaration if present.
-            this.visitPropertyAccessors(leftExpr, /* setter */ false, /* getter */ true);
-        }
-        return true;
-    }
-    getResolvedNodeUsage(searchNode) {
-        this.nodeQueue = [searchNode];
-        this.visitedJumpExprNodes.clear();
-        this.context.clear();
-        // Copy base context values into the current function block context. The
-        // base context is useful if nodes need to be mapped to other nodes. e.g.
-        // 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 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.
-            if (ts.isCallExpression(node)) {
-                this.addJumpExpressionToQueue(node);
-            }
-            // Handle new expressions that cause a jump in control flow. We resolve the
-            // constructor declaration of the target class and add it to the node queue.
-            if (ts.isNewExpression(node)) {
-                this.addNewExpressionToQueue(node);
-            }
-            // We also need to handle binary expressions where a value can be either assigned to
-            // the property, or a value is read from a property expression. Depending on the
-            // binary expression operator, setters or getters need to be analyzed.
-            if (ts.isBinaryExpression(node)) {
-                // In case the binary expression contained a property expression on the left side, we
-                // don't want to continue visiting this property expression on its own. This is necessary
-                // because visiting the expression on its own causes a loss of context. e.g. property
-                // access expressions *do not* always cause a value read (e.g. property assignments)
-                if (this.visitBinaryExpression(node)) {
-                    this.nodeQueue.push(node.right);
-                    continue;
-                }
-            }
-            // Handle property access expressions. Property expressions which are part of binary
-            // expressions won't be added to the node queue, so these access expressions are
-            // guaranteed to be "read" accesses and we need to check the "getter" declaration.
-            if (ts.isPropertyAccessExpression(node)) {
-                this.visitPropertyAccessors(node, /* setter */ false, /* getter */ true);
-            }
-            // Do not visit nodes that declare a block of statements but are not executed
-            // synchronously (e.g. function declarations). We only want to check TypeScript
-            // nodes which are synchronously executed in the control flow.
-            if (!isFunctionLikeDeclaration(node)) {
-                this.nodeQueue.push(...node.getChildren());
-            }
-        }
-        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 = 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 (isFunctionLikeDeclaration(node) && !!node.body) {
-                this.ambiguousNodeQueue.push(node.body);
-            }
-        });
-    }
-    /**
-     * Resolves a given node from the context. In case the node is not mapped in
-     * the context, the original node is returned.
-     */
-    _resolveNodeFromContext(node) {
-        if (this.context.has(node)) {
-            return this.context.get(node);
-        }
-        return node;
-    }
-    /**
-     * Updates the context to reflect the newly set parameter values. This allows future
-     * references to function parameters to be resolved to the actual node through the context.
-     */
-    _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._resolveDeclarationOfNode(argumentNode));
-            }
-            else {
-                this.context.set(parameter, argumentNode);
-            }
-        });
-    }
-    /**
-     * 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.
-     */
-    _resolveDeclarationOfNode(node) {
-        const symbol = this._getDeclarationSymbolOfNode(node);
-        if (!symbol || !symbol.valueDeclaration) {
-            return node;
-        }
-        return this._resolveNodeFromContext(symbol.valueDeclaration);
-    }
-    /**
-     * Gets the declaration symbol of a given TypeScript node. Resolves aliased
-     * symbols to the symbol containing the value declaration.
-     */
-    _getDeclarationSymbolOfNode(node) {
-        let symbol = this.typeChecker.getSymbolAtLocation(node);
-        if (!symbol) {
-            return null;
-        }
-        // Resolve the symbol to it's original declaration symbol.
-        while (symbol.flags & ts.SymbolFlags.Alias) {
-            symbol = this.typeChecker.getAliasedSymbol(symbol);
-        }
-        return symbol;
-    }
-    /** Gets the symbol of the given property access expression. */
-    _getPropertyAccessSymbol(node) {
-        let propertySymbol = this._getDeclarationSymbolOfNode(node.name);
-        if (!propertySymbol || !propertySymbol.valueDeclaration) {
-            return null;
-        }
-        if (!this.context.has(propertySymbol.valueDeclaration)) {
-            return propertySymbol;
-        }
-        // In case the context has the value declaration of the given property access
-        // name identifier, we need to replace the "propertySymbol" with the symbol
-        // referring to the resolved symbol based on the context. e.g. abstract properties
-        // can ultimately resolve into an accessor declaration based on the implementation.
-        const contextNode = this._resolveNodeFromContext(propertySymbol.valueDeclaration);
-        if (!ts.isAccessor(contextNode)) {
-            return null;
-        }
-        // Resolve the symbol referring to the "accessor" using the name identifier
-        // of the accessor declaration.
-        return this._getDeclarationSymbolOfNode(contextNode.name);
-    }
-}
-//# 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 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 * 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?.declarations === undefined || propertySymbol.declarations.length === 0 ||\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/super_class_context.mjs

@@ -1,38 +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
- */
-import * as ts from 'typescript';
-import { isFunctionLikeDeclaration } from '../../../../utils/typescript/functions';
-import { hasModifier } from '../../../../utils/typescript/nodes';
-import { getPropertyNameText } from '../../../../utils/typescript/property_name';
-import { getSuperClassDeclarations } from '../../angular/super_class';
-/**
- * Updates the specified function context to map abstract super-class class members
- * to their implementation TypeScript nodes. This allows us to run the declaration visitor
- * for the super class with the context of the "baseClass" (e.g. with implemented abstract
- * class members)
- */
-export function updateSuperClassAbstractMembersContext(baseClass, context, classMetadataMap) {
-    getSuperClassDeclarations(baseClass, classMetadataMap).forEach(superClassDecl => {
-        superClassDecl.members.forEach(superClassMember => {
-            if (!superClassMember.name || !hasModifier(superClassMember, ts.SyntaxKind.AbstractKeyword)) {
-                return;
-            }
-            // Find the matching implementation of the abstract declaration from the super class.
-            const baseClassImpl = baseClass.members.find(baseClassMethod => !!baseClassMethod.name &&
-                getPropertyNameText(baseClassMethod.name) ===
-                    getPropertyNameText(superClassMember.name));
-            if (!baseClassImpl || !isFunctionLikeDeclaration(baseClassImpl) || !baseClassImpl.body) {
-                return;
-            }
-            if (!context.has(superClassMember)) {
-                context.set(superClassMember, baseClassImpl);
-            }
-        });
-    });
-}
-//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/static-queries/strategies/usage_strategy/template_usage_visitor.mjs

@@ -1,80 +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
- */
-import { ImplicitReceiver, RecursiveAstVisitor } from '@angular/compiler';
-import { NullVisitor, visitAll } from '@angular/compiler/src/render3/r3_ast';
-/**
- * AST visitor that traverses the Render3 HTML AST in order to check if the given
- * query property is accessed statically in the template.
- */
-export class TemplateUsageVisitor extends NullVisitor {
-    constructor(queryPropertyName) {
-        super();
-        this.queryPropertyName = queryPropertyName;
-        this.hasQueryTemplateReference = false;
-        this.expressionAstVisitor = new ExpressionAstVisitor(this.queryPropertyName);
-    }
-    /** Checks whether the given query is statically accessed within the specified HTML nodes. */
-    isQueryUsedStatically(htmlNodes) {
-        this.hasQueryTemplateReference = false;
-        this.expressionAstVisitor.hasQueryPropertyRead = false;
-        // Visit all AST nodes and check if the query property is used statically.
-        visitAll(this, htmlNodes);
-        return !this.hasQueryTemplateReference && this.expressionAstVisitor.hasQueryPropertyRead;
-    }
-    visitElement(element) {
-        // In case there is a template references variable that matches the query property
-        // name, we can finish this visitor as such a template variable can be used in the
-        // entire template and the query therefore can't be accessed from the template.
-        if (element.references.some(r => r.name === this.queryPropertyName)) {
-            this.hasQueryTemplateReference = true;
-            return;
-        }
-        visitAll(this, element.attributes);
-        visitAll(this, element.inputs);
-        visitAll(this, element.outputs);
-        visitAll(this, element.children);
-    }
-    visitTemplate(template) {
-        visitAll(this, template.attributes);
-        visitAll(this, template.inputs);
-        visitAll(this, template.outputs);
-        // We don't want to visit any children of the template as these never can't
-        // access a query statically. The templates can be rendered in the ngAfterViewInit"
-        // lifecycle hook at the earliest.
-    }
-    visitBoundAttribute(attribute) {
-        attribute.value.visit(this.expressionAstVisitor, attribute.sourceSpan);
-    }
-    visitBoundText(text) {
-        text.value.visit(this.expressionAstVisitor, text.sourceSpan);
-    }
-    visitBoundEvent(node) {
-        node.handler.visit(this.expressionAstVisitor, node.handlerSpan);
-    }
-}
-/**
- * AST visitor that checks if the given expression contains property reads that
- * refer to the specified query property name.
- */
-class ExpressionAstVisitor extends RecursiveAstVisitor {
-    constructor(queryPropertyName) {
-        super();
-        this.queryPropertyName = queryPropertyName;
-        this.hasQueryPropertyRead = false;
-    }
-    visitPropertyRead(node, span) {
-        // The receiver of the property read needs to be "implicit" as queries are accessed
-        // from the component instance and not from other objects.
-        if (node.receiver instanceof ImplicitReceiver && node.name === this.queryPropertyName) {
-            this.hasQueryPropertyRead = true;
-            return;
-        }
-        super.visitPropertyRead(node, span);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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