@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/schematics/migrations/static-queries/strategies/timing-strategy.d.ts

@@ -1,19 +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
- */
-/// <amd-module name="@angular/core/schematics/migrations/static-queries/strategies/timing-strategy" />
-import { NgQueryDefinition, QueryTiming } from '../angular/query-definition';
-export interface TimingStrategy {
-    /** Sets up the given strategy. Throws if the strategy could not be set up. */
-    setup(): void;
-    /** Detects the timing result for a given query. */
-    detectTiming(query: NgQueryDefinition): TimingResult;
-}
-export declare type TimingResult = {
-    timing: QueryTiming | null;
-    message?: string;
-};

package/schematics/migrations/static-queries/strategies/timing-strategy.js

@@ -1,20 +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
- */
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define("@angular/core/schematics/migrations/static-queries/strategies/timing-strategy", ["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltaW5nLXN0cmF0ZWd5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zY2hlbWF0aWNzL21pZ3JhdGlvbnMvc3RhdGljLXF1ZXJpZXMvc3RyYXRlZ2llcy90aW1pbmctc3RyYXRlZ3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7TmdRdWVyeURlZmluaXRpb24sIFF1ZXJ5VGltaW5nfSBmcm9tICcuLi9hbmd1bGFyL3F1ZXJ5LWRlZmluaXRpb24nO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRpbWluZ1N0cmF0ZWd5IHtcbiAgLyoqIFNldHMgdXAgdGhlIGdpdmVuIHN0cmF0ZWd5LiBUaHJvd3MgaWYgdGhlIHN0cmF0ZWd5IGNvdWxkIG5vdCBiZSBzZXQgdXAuICovXG4gIHNldHVwKCk6IHZvaWQ7XG4gIC8qKiBEZXRlY3RzIHRoZSB0aW1pbmcgcmVzdWx0IGZvciBhIGdpdmVuIHF1ZXJ5LiAqL1xuICBkZXRlY3RUaW1pbmcocXVlcnk6IE5nUXVlcnlEZWZpbml0aW9uKTogVGltaW5nUmVzdWx0O1xufVxuXG5leHBvcnQgdHlwZSBUaW1pbmdSZXN1bHQgPSB7XG4gIHRpbWluZzogUXVlcnlUaW1pbmd8bnVsbDtcbiAgbWVzc2FnZT86IHN0cmluZztcbn07XG4iXX0=

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

@@ -1,82 +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
- */
-/// <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
- * 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 declare class DeclarationUsageVisitor {
-    private declaration;
-    private typeChecker;
-    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 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.
-     */
-    private context;
-    constructor(declaration: ts.Node, typeChecker: ts.TypeChecker, baseContext?: FunctionContext);
-    private isReferringToSymbol;
-    private addJumpExpressionToQueue;
-    private addNewExpressionToQueue;
-    private visitPropertyAccessors;
-    private visitBinaryExpression;
-    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.
-     */
-    private _resolveNodeFromContext;
-    /**
-     * 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.
-     */
-    private _updateContext;
-    /**
-     * 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 _resolveDeclarationOfNode;
-    /**
-     * Gets the declaration symbol of a given TypeScript node. Resolves aliased
-     * symbols to the symbol containing the value declaration.
-     */
-    private _getDeclarationSymbolOfNode;
-    /** Gets the symbol of the given property access expression. */
-    private _getPropertyAccessSymbol;
-}

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

@@ -1,369 +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
- */
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        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", "@angular/core/schematics/utils/typescript/property_name"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.DeclarationUsageVisitor = exports.ResolvedUsage = void 0;
-    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.
-     */
-    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.
-     */
-    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 = (0, functions_1.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 ((0, functions_1.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 (!(0, 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.
-            this._updateContext(callExpression.arguments, expressionDecl.parameters);
-            this.visitedJumpExprNodes.add(expressionDecl);
-            this.nodeQueue.push(expressionDecl.body);
-        }
-        addNewExpressionToQueue(node) {
-            const newExprSymbol = this._getDeclarationSymbolOfNode((0, functions_1.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 = (0, functions_1.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 (!(0, functions_1.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 = (0, 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 ((0, 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
-         * 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);
-        }
-    }
-    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 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.d.ts

@@ -1,18 +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
- */
-/// <amd-module name="@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/super_class_context" />
-import * as ts from 'typescript';
-import { ClassMetadataMap } from '../../angular/ng_query_visitor';
-import { FunctionContext } from './declaration_usage_visitor';
-/**
- * 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 declare function updateSuperClassAbstractMembersContext(baseClass: ts.ClassDeclaration, context: FunctionContext, classMetadataMap: ClassMetadataMap): void;