Checks whether the node is (or was) a call to $jscomp.polyfill.
182673
private static boolean isPolyfillDefinition(Node callee) {
    // If the callee is just $jscomp.polyfill then it's easy.
    if (callee.matchesQualifiedName("$jscomp.polyfill")
        || callee.matchesQualifiedName("$jscomp$polyfill")) {
      return true;
    }
    // It's possible that the function has been inlined, so look for
    // a four-parameter function with parameters who have the correct
    // prefix (since a disambiguate suffix may have been added).
    if (callee.isFunction()) {
      Node paramList = callee.getSecondChild();
      Node param = paramList.getFirstChild();
      if (paramList.hasXChildren(4)) {
        for (String name : POLYFILL_PARAMETERS) {
          if (!param.isName() || !param.getString().startsWith(name)) {
            return false;
          }
          param = param.getNext();
        }
        return true;
      }
    }
    return false;
  }
851662
function check(node) {
            if (TARGET_NODE_TYPE.test(node.parent.type) &&
                isMixedWithParent(node) &&
                !shouldIgnore(node)
            ) {
                reportBothOperators(node);
            }
        }
1176004
function isNodeWrapped(node, types) {
    var parents = getParents(node);
    var parentsTypes = parents.map(function(parent) {
        return parent.type;
    });
    return types.some(function(type) {
        return parentsTypes.some(function(parentType) {
            return parentType === type;
        });
    });
}
281406
private boolean isJSDocOnFunctionNode(Node n, JSDocInfo info) {
    switch (n.getToken()) {
      case FUNCTION:
      case GETTER_DEF:
      case SETTER_DEF:
      case MEMBER_FUNCTION_DEF:
      case STRING_KEY:
      case COMPUTED_PROP:
      case EXPORT:
        return true;
      case GETELEM:
      case GETPROP:
        if (n.getFirstChild().isQualifiedName()) {
          // assume qualified names may be function declarations
          return true;
        }
        return false;
      case VAR:
      case LET:
      case CONST:
      case ASSIGN:
        {
          Node lhs = n.getFirstChild();
          Node rhs = NodeUtil.getRValueOfLValue(lhs);
          if (rhs != null && isClass(rhs) && !info.isConstructor()) {
            return false;
          }

          // TODO(b/124081098): Check that the RHS of the assignment is a
          // function. Note that it can be a FUNCTION node, but it can also be
          // a call to goog.abstractMethod, goog.functions.constant, etc.
          return true;
        }
      default:
        return false;
    }
  }
20598
function is$ (node) {
  return node.callee.name === '$' || (node.callee.property && node.callee.property.name === '$')
}
727466
public function isFunctionCall($node, string $function): Bool
    {
        if ($node instanceof Node && $node->kind === \ast\AST_CALL) {
            $expr = $node->children['expr'];

            if ($expr->kind === \ast\AST_NAME && $expr->children['name'] === $function) {
                return true;
            }
        }

        return false;
    }
123500
function checkImportCall(node) {
    if (node.callee.type !== 'Import') return
    if (node.arguments.length !== 1) return

    const modulePath = node.arguments[0]
    if (modulePath.type !== 'Literal') return
    if (typeof modulePath.value !== 'string') return

    checkSourceValue(modulePath, node)
  }
1344027
function isInteraction (node) {
  return isLLCall(node) || isLLSend(node) || isExternalDirectCall(node) || isTransfer(node) || isLLCall050(node) || isLLSend050(node)
}
193595
function checkFunction(node) {
            if (!node.generator) {
                return;
            }

            const starToken = getStarToken(node);
            const prevToken = sourceCode.getTokenBefore(starToken);
            const nextToken = sourceCode.getTokenAfter(starToken);

            let kind = "named";

            if (node.parent.type === "MethodDefinition" || (node.parent.type === "Property" && node.parent.method)) {
                kind = "method";
            } else if (!node.id) {
                kind = "anonymous";
            }

            // Only check before when preceded by `function`|`static` keyword
            if (!(kind === "method" && starToken === sourceCode.getFirstToken(node.parent))) {
                checkSpacing(kind, "before", prevToken, starToken);
            }

            checkSpacing(kind, "after", starToken, nextToken);
        }
881373
function checkASTandNode(ast, node) {
  typeCheckObject(ast, 'ast');
  typeCheckObject(node, 'node');
  runValidator(ast, 'ast');
  runValidator(node, 'node');
}
491493
def visit_Call(self, nodeCall):
        
        super(PatternFinder, self).generic_visit(nodeCall)
        # Capture assignment like 'f = getattr(...)'.
        if hasattr(nodeCall.func, "func"):
            # In this case, the statement should be
            # 'f = getattr(...)()'.
            nodeCall = nodeCall.func
        # Make sure the function's name is 'getattr'.
        if not hasattr(nodeCall.func, "id"):
            return
        if nodeCall.func.id != "getattr":
            return

        # Capture 'f = getattr(foo, "bar_%s" % baz )' or
        # 'f = getattr(foo, "bar_" + baz )'.
        nodeArgument = nodeCall.args[1]
        if not isinstance(nodeArgument, ast.BinOp):
            return
        operation = nodeArgument.op
        if type(operation) not in [ast.Mod, ast.Add]:
            return
        nodePattern = nodeArgument.left
        if not isinstance(nodePattern, ast.Str):
            return
        pattern = nodePattern.s
        if not ((type(operation) == ast.Add and pattern.endswith("_")) or
                (pattern.count("%s") == 1 and pattern.endswith("_%s"))):
            return
        pattern = pattern.replace("%s", "")
        if pattern[:1].isalpha() and not pattern[:1].islower():
            self.patternsClass.add(pattern)
        else:
            self.patternsFunc.add(pattern)
975409
def is_method_call(node, method_name):
    

    if not isinstance(node, nodes.Call):
        return False

    if isinstance(node.node, nodes.Getattr):
        # e.g. foo.bar()
        method = node.node.attr

    elif isinstance(node.node, nodes.Name):
        # e.g. bar()
        method = node.node.name

    elif isinstance(node.node, nodes.Getitem):
        # e.g. foo["bar"]()
        method = node.node.arg.value

    else:
        return False

    if isinstance(method_name, (list, tuple)):
        return method in method_name

    return method == method_name
1214229
function isInternalNode (node) {
  let tagName = (typeof node === 'string') ? node : node.tagName
  if (tagName && tagName.toLowerCase().indexOf('mip-i-') === 0) {
    return true
  }

  if (node.tagName && (node.hasAttribute('placeholder') ||
      node.hasAttribute('fallback') ||
      node.hasAttribute('overflow'))) {
    return true
  }
  return false
}
410837
function isLintablePromiseCatch(node) {
	const {callee} = node;

	if (callee.type !== 'MemberExpression') {
		return false;
	}

	const {property} = callee;

	if (property.type !== 'Identifier' || property.name !== 'catch') {
		return false;
	}

	if (node.arguments.length === 0) {
		return false;
	}

	const [arg0] = node.arguments;

	return arg0.type === 'FunctionExpression' || arg0.type === 'ArrowFunctionExpression';
}
1335465
static boolean isDirectCallNodeReplacementPossible(Node fnNode) {
    // Only inline single-statement functions
    Node block = NodeUtil.getFunctionBody(fnNode);

    // Check if this function is suitable for direct replacement of a CALL node:
    // a function that consists of single return that returns an expression.
    if (!block.hasChildren()) {
      // special case empty functions.
      return true;
    } else if (block.hasOneChild()) {
      // Only inline functions that return something.
      if (block.getFirstChild().isReturn()
          && block.getFirstFirstChild() != null) {
        return true;
      }
    }

    return false;
  }
680708
function isLLCall050 (node) {
  return isMemberAccess(node,
          exactMatch(util.escapeRegExp(lowLevelCallTypes['CALL-v0.5'].type)),
          undefined, exactMatch(basicTypes.PAYABLE_ADDRESS), exactMatch(lowLevelCallTypes['CALL-v0.5'].ident))
}
45391
function isBlockBlockHashAccess (node) {
  return isSpecialVariableAccess(node, specialVariables.BLOCKHASH) || isBuiltinFunctionCall(node) && getLocalCallName(node) === 'blockhash'
}