Make the keywords entry for an ast.Call node.
559070
def make_call_keywords(stack_builders, count):
    
    out = []
    for _ in range(count):
        value = make_expr(stack_builders)
        load_kwname = stack_builders.pop()
        if not isinstance(load_kwname, instrs.LOAD_CONST):
            raise DecompilationError(
                "Expected a LOAD_CONST, but got %r" % load_kwname
            )
        if not isinstance(load_kwname.arg, str):
            raise DecompilationError(
                "Expected LOAD_CONST of a str, but got %r." % load_kwname,
            )
        out.append(ast.keyword(arg=load_kwname.arg, value=value))
    out.reverse()
    return out
576124
def visit_FunctionCall(self, node):
        """"""
        function_name = node.identifier.name
        call = self.table[function_name]
        if call is None:
            raise SementicError(f"Function `{function_name}` not declared.")
        else:
            call = call._node

        if isinstance(call, AST):
            if len(call.parameters) != len(node.parameters):
                raise SementicError(
                    "Mismatch between call and function parameters number."
                )

            current_table = self.table.stack.current
            functions_in_table = {
                key: current_table[key]
                for key in current_table
                if isinstance(current_table[key], FunctionSymbol)
            }

            if self.table.name == function_name:
                # End the visit in case of recursion
                return

            self.table.append_table(function_name, **functions_in_table)
            self.visit(call)
            self.table.pop_table()
993745
def generic_visit(self, node):
        """"""
        if node.__class__.__name__ == 'Name':
            if node.ctx.__class__ == ast.Load and node.id not in self.names:
                self.names.append(node.id)
        ast.NodeVisitor.generic_visit(self, node)
563498
def generic_visit(self, node):
        """"""
        for _, value in ast.iter_fields(node):
            if isinstance(value, list):
                self._handle_ast_list(value)
                for item in value:
                    if isinstance(item, ast.AST):
                        self.visit(item)
            elif isinstance(value, ast.AST):
                self.visit(value)
500544
function visitEntry (pkey, context, callback) {
    _(context).chain().keys().each(function (key) {
        var entry = context[key], curkey = pkey?(pkey + '.' + key):key;
        if(_.isFunction(entry) || _.isString(entry) || _.isBoolean(entry) ||
           _.isArray(entry) || _.isNumber(entry) || _.isRegExp(entry)) {//entry is a leaf node
            callback(curkey, entry);
        } else {//entry is not a leaf node
            visitEntry (curkey, entry, callback)
        }
    });
}
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)
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)
894936
def make_node(cls, func_name, lineno, type_=None):
        
        entry = global_.SYMBOL_TABLE.declare_func(func_name, lineno, type_=type_)
        if entry is None:
            return None

        entry.declared = True
        return cls(entry, lineno)
956404
def visit_Call(self, node):
        """"""
        if node in self.potential_iterator:
            matched_path = self.find_matching_builtin(node)
            if matched_path is None:
                return self.generic_visit(node)

            # Special handling for map which can't be turn to imap with None as
            # a parameter as map(None, [1, 2]) == [1, 2] while
            # list(imap(None, [1, 2])) == [(1,), (2,)]
            if (matched_path[1] == "map" and
                    MODULES["__builtin__"]["None"] in
                    self.aliases[node.args[0]]):
                return self.generic_visit(node)

            # if a dtype conversion is implied
            if matched_path[1] in ('array', 'asarray') and len(node.args) != 1:
                return self.generic_visit(node)

            path = EQUIVALENT_ITERATORS[matched_path]
            if path:
                node.func = path_to_attr(path)
                self.use_itertools |= path[0] == 'itertools'
            else:
                node = node.args[0]

            self.update = True
        return self.generic_visit(node)
451646
function keywordMatch(mode, keywords) {
    var keyword = keywords[0]

    if (language[keyInsensitive]) {
      keyword = keyword.toLowerCase()
    }

    return own.call(mode.keywords, keyword) && mode.keywords[keyword]
  }
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
106136
def visit_Call_35(self, call):
        
        new_func, func_expl = self.visit(call.func)
        arg_expls = []
        new_args = []
        new_kwargs = []
        for arg in call.args:
            res, expl = self.visit(arg)
            arg_expls.append(expl)
            new_args.append(res)
        for keyword in call.keywords:
            res, expl = self.visit(keyword.value)
            new_kwargs.append(ast.keyword(keyword.arg, res))
            if keyword.arg:
                arg_expls.append(keyword.arg + "=" + expl)
            else: ## **args have `arg` keywords with an .arg of None
                arg_expls.append("**" + expl)

        expl = "%s(%s)" % (func_expl, ', '.join(arg_expls))
        new_call = ast.Call(new_func, new_args, new_kwargs)
        res = self.assign(new_call)
        res_expl = self.explanation_param(self.display(res))
        outer_expl = "%s\n{%s = %s\n}" % (res_expl, res_expl, expl)
        return res, outer_expl
701859
function(jid, name, node, call_back)
    {
        if (node && !call_back)
            return false;
        this._items.push({jid: jid, name: name, node: node, call_back: call_back});
        return true;
    }
1295748
function (node) {
                _addResult(node);
                ASTWalker.simple(node, {
                    /*
                        class <className> () {
                            <methodName> () {
                            
                            }
                        }
                    */
                    MethodDefinition: function (methodNode) {
                        _addResult(methodNode, methodNode.key.start, node.id.name);
                    }
                });
            }
281366
def visit_Call(self, node):
        
        md.visit(self, node)
        for arg in node.args:
            self.visit(arg)
        self.func_args_lazyness(node.func, node.args, node)
        self.visit(node.func)
606871
def call(self, tokens, *args, **kwargs):
        
        tokens.append([evaluate, [args, kwargs], {}])
        return tokens
729118
def visit_keyword(self, node: AST, dfltChaining: bool = True) -> str:
        """"""
        arg = node.arg
        if arg is None:
            return f"**{self.visit(node.value)}"
        else:
            return f"{arg}={self.visit(node.value)}"