A new CALL node with the "FREE_CALL" set based on call target.
500058
static Node newCallNode(Node callTarget, Node... parameters) {
    boolean isFreeCall = !isGet(callTarget);
    Node call = IR.call(callTarget);
    call.putBooleanProp(Node.FREE_CALL, isFreeCall);
    for (Node parameter : parameters) {
      call.addChildToBack(parameter);
    }
    return call;
  }
1159511
def replace_all_calls(mod, orig, repl):
    
    rc = ReplaceCalls(orig, repl)
    rc.visit(mod)
    return rc.calls
674115
def add_call(self, func):
        """"""
        self.trace.append("{} ({}:{})".format(
            object_name(func),
            inspect.getsourcefile(func),
            inspect.getsourcelines(func)[1]))

        return self
1007257
def track_method_call(definition, name, node)
      method   = definition.lookup(definition.method_call_type, name)
      current  = current_scope
      location = {
        :line   => node.line,
        :column => node.column,
        :file   => node.file
      }

      # Add the call to the current scope if we're dealing with a writable
      # method definition.
      if current.respond_to?(:calls) and !current.frozen?
        current.calls.push(
          MethodCallInfo.new(location.merge(:definition => method))
        )
      end

      # Add the caller to the called method, this allows for inverse lookups.
      unless method.frozen?
        method.callers.push(
          MethodCallInfo.new(location.merge(:definition => definition))
        )
      end
    end
949042
def assignment_call_node(self, left_hand_label, ast_node):
        """"""
        self.undecided = True  # Used for handling functions in assignments

        call = self.visit(ast_node.value)
        call_label = call.left_hand_side

        call_assignment = AssignmentCallNode(
            left_hand_label + ' = ' + call_label,
            left_hand_label,
            ast_node,
            [call.left_hand_side],
            line_number=ast_node.lineno,
            path=self.filenames[-1],
            call_node=call
        )
        call.connect(call_assignment)

        self.nodes.append(call_assignment)
        self.undecided = False

        return call_assignment
1139447
def extract_call(self, call, from_name, settings):
        '''
        
        '''

        call = defaultdict(lambda: None, call[0])

        try:
            call['section'] = settings['section']
        except KeyError:
            call['section'] = ''

        project = call['project']

        # If there is more than one call in a single file
        if type(project) == list:
            calls = []

            for name in project:
                calls.append(self.create_call(name, call, from_name))

            return calls
        else:
            return [self.create_call(project, call, from_name)]
1018727
def getStartNodes(fdefs,calls):
    ''''''
    s=[]
    for source in fdefs:
        for fn in fdefs[source]:
            inboundEdges=False
            for call in calls:
                if call.target==fn:
                    inboundEdges=True
            if not inboundEdges:
                s.append(fn)
    return s
1046581
public Iterator<CallSite> callSiteIterator() {
        return new Iterator<CallSite>() {
            private final Iterator<CallGraphEdge> iter = callGraph.edgeIterator();

            @Override
            public boolean hasNext() {
                return iter.hasNext();
            }

            @Override
            public CallSite next() {
                return iter.next().getCallSite();
            }

            @Override
            public void remove() {
                iter.remove();
            }
        };
    }
816184
def visit_Call(self, node):
        
        func_aliases = self.aliases[node.func]
        if len(func_aliases) == 1:
            function_def = next(iter(func_aliases))
            if (isinstance(function_def, ast.FunctionDef) and
                    function_def.name in self.inlinable):
                self.update = True
                to_inline = copy.deepcopy(self.inlinable[function_def.name])
                arg_to_value = dict()
                values = node.args
                values += to_inline.args.defaults[len(node.args) -
                                                  len(to_inline.args.args):]
                for arg_fun, arg_call in zip(to_inline.args.args, values):
                    v_name = "__pythran_inline{}{}{}".format(function_def.name,
                                                             arg_fun.id,
                                                             self.call_count)
                    new_var = ast.Name(id=v_name,
                                       ctx=ast.Store(),
                                       annotation=None)
                    self.defs.append(ast.Assign(targets=[new_var],
                                                value=arg_call))
                    arg_to_value[arg_fun.id] = ast.Name(id=v_name,
                                                        ctx=ast.Load(),
                                                        annotation=None)
                self.call_count += 1
                return Inliner(arg_to_value).visit(to_inline.body[0])
        return node
886514
def visit_call(self, node, parent):
        """"""
        newnode = nodes.Call(node.lineno, node.col_offset, parent)
        starargs = _visit_or_none(node, "starargs", self, newnode)
        kwargs = _visit_or_none(node, "kwargs", self, newnode)
        args = [self.visit(child, newnode) for child in node.args]

        if node.keywords:
            keywords = [self.visit(child, newnode) for child in node.keywords]
        else:
            keywords = None
        if starargs:
            new_starargs = nodes.Starred(
                col_offset=starargs.col_offset,
                lineno=starargs.lineno,
                parent=starargs.parent,
            )
            new_starargs.postinit(value=starargs)
            args.append(new_starargs)
        if kwargs:
            new_kwargs = nodes.Keyword(
                arg=None,
                col_offset=kwargs.col_offset,
                lineno=kwargs.lineno,
                parent=kwargs.parent,
            )
            new_kwargs.postinit(value=kwargs)
            if keywords:
                keywords.append(new_kwargs)
            else:
                keywords = [new_kwargs]

        newnode.postinit(self.visit(node.func, newnode), args, keywords)
        return newnode
24169
def visit_Call(self, node):
        
        args = [self.visit(arg) for arg in node.args]
        func = self.visit(node.func)
        params = args + [func or []]
        return list({frozenset.union(*p) for p in itertools.product(*params)})
834007
def _get_call_names_helper(node):
    """"""
    if isinstance(node, ast.Name):
        if node.id not in BLACK_LISTED_CALL_NAMES:
            yield node.id
    elif isinstance(node, ast.Subscript):
        yield from _get_call_names_helper(node.value)
    elif isinstance(node, ast.Str):
        yield node.s
    elif isinstance(node, ast.Attribute):
        yield node.attr
        yield from _get_call_names_helper(node.value)
355164
def method_call(receiver, message, args, pseudo_type=None):
    ''''''

    if not isinstance(receiver, Node):
        receiver = local(receiver)
    return Node('method_call', receiver=receiver, message=message, args=args, pseudo_type=pseudo_type)
558685
def visit_Call(self, node):  # type: (ast.Call) -> None
        """"""
        if isinstance(node.func, ast.Name) and node.func.id == 'breakpoint':
            st = Debug(node.lineno, node.col_offset, node.func.id, 'called')
            self.breakpoints.append(st)
        self.generic_visit(node)
1233194
function create(context) {
    return {
        CallExpression(node) {
            if (isDefineCall(node) && !isValidDefine(node)) {
                context.report(node, message);
            }
        }
    };
}
200104
def kwargs_as_assignments(call_node, parent):
    """"""
    if not isinstance(call_node, ast.Call):
        raise TypeError('node must be an ast.Call')

    if len(call_node.args) > 0:
        raise ValueError('positional args not allowed')

    for keyword in call_node.keywords:
        dst_name = keyword.arg

        if dst_name.startswith('gl_'):
            # Write to builtins directly
            target = [ast.Name(id=keyword.arg, ctx=ast.Load())]
        else:
            # Non-builtins are part of an interface block
            target = [ast.Attribute(value=parent, attr=keyword.arg,
                                    ctx=ast.Store())]

        yield NoDeclAssign(targets=target, value=keyword.value)
1048876
private Node tryFoldStandardConstructors(Node n) {
    checkState(n.isNew());

    if (canFoldStandardConstructors(n)) {
      n.setToken(Token.CALL);
      n.putBooleanProp(Node.FREE_CALL, true);
      reportChangeToEnclosingScope(n);
    }

    return n;
  }