| /** |
| * @license |
| * Copyright Google Inc. 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 }); |
| 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 = 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 (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 (!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(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 || !propertySymbol.declarations.length || |
| (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 = 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 (!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 = 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 |
| * 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 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"]} |
