def call(self, decl: FuncDecl, args: Sequence[Value],
arg_kinds: List[int],
arg_names: Sequence[Optional[str]],
line: int) -> Value:
# Normalize args to positionals.
args = self.native_args_to_positional(
args, arg_kinds, arg_names, decl.sig, line)
return self.add(Call(decl, args, line))
def test_call_two_args(self) -> None:
decl = FuncDecl(
'myfn', None, 'mod',
FuncSignature([
RuntimeArg('m', int_rprimitive),
RuntimeArg('n', int_rprimitive)
], int_rprimitive))
self.assert_emit(Call(decl, [self.m, self.k], 55),
"cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);")
def visit_call_expr(self, expr: CallExpr) -> Register:
if isinstance(expr.callee, MemberExpr):
is_module_call = self.is_module_member_expr(expr.callee)
if expr.callee.expr in self.types and not is_module_call:
target = self.translate_special_method_call(expr.callee, expr)
if target:
return target
# Either its a module call or translating to a special method call failed, so we have
# to fallback to a PyCall
function = self.accept(expr.callee)
return self.py_call(function, expr.args, self.node_type(expr))
assert isinstance(expr.callee, NameExpr)
fn = expr.callee.name # TODO: fullname
if fn == 'len' and len(expr.args) == 1 and expr.arg_kinds == [ARG_POS]:
target = self.alloc_target(IntRType())
arg = self.accept(expr.args[0])
expr_rtype = self.node_type(expr.args[0])
if expr_rtype.name == 'list':
self.add(PrimitiveOp(target, PrimitiveOp.LIST_LEN, arg))
elif expr_rtype.name == 'sequence_tuple':
self.add(
PrimitiveOp(target, PrimitiveOp.HOMOGENOUS_TUPLE_LEN, arg))
elif isinstance(expr_rtype, TupleRType):
self.add(LoadInt(target, len(expr_rtype.types)))
else:
assert False, "unsupported use of len"
# Handle conversion to sequence tuple
elif fn == 'tuple' and len(
expr.args) == 1 and expr.arg_kinds == [ARG_POS]:
target = self.alloc_target(SequenceTupleRType())
arg = self.accept(expr.args[0])
self.add(
PrimitiveOp(target, PrimitiveOp.LIST_TO_HOMOGENOUS_TUPLE, arg))
else:
target_type = self.node_type(expr)
if not (self.is_native_name_expr(expr.callee)):
function = self.accept(expr.callee)
return self.py_call(function, expr.args, target_type)
target = self.alloc_target(target_type)
args = [self.accept(arg) for arg in expr.args]
self.add(Call(target, fn, args))
return target
def allocate_class(self, cdef: ClassDef) -> Value:
# OK AND NOW THE FUN PART
base_exprs = cdef.base_type_exprs + cdef.removed_base_type_exprs
if base_exprs:
bases = [self.accept(x) for x in base_exprs]
tp_bases = self.primitive_op(new_tuple_op, bases, cdef.line)
else:
tp_bases = self.add(
LoadErrorValue(object_rprimitive, is_borrowed=True))
modname = self.load_static_unicode(self.module_name)
template = self.add(
LoadStatic(object_rprimitive, cdef.name + "_template",
self.module_name, NAMESPACE_TYPE))
# Create the class
tp = self.primitive_op(pytype_from_template_op,
[template, tp_bases, modname], cdef.line)
# Immediately fix up the trait vtables, before doing anything with the class.
ir = self.mapper.type_to_ir[cdef.info]
if not ir.is_trait and not ir.builtin_base:
self.add(
Call(
FuncDecl(cdef.name + '_trait_vtable_setup', None,
self.module_name,
FuncSignature([], bool_rprimitive)), [], -1))
# Populate a '__mypyc_attrs__' field containing the list of attrs
self.primitive_op(py_setattr_op, [
tp,
self.load_static_unicode('__mypyc_attrs__'),
self.create_mypyc_attrs_tuple(self.mapper.type_to_ir[cdef.info],
cdef.line)
], cdef.line)
# Save the class
self.add(InitStatic(tp, cdef.name, self.module_name, NAMESPACE_TYPE))
# Add it to the dict
self.primitive_op(dict_set_item_op, [
self.builder.load_globals_dict(),
self.load_static_unicode(cdef.name),
tp,
], cdef.line)
return tp
def test_call_no_return(self) -> None:
self.assert_emit(Call(None, 'myfn', [self.m, self.k]),
"CPyDef_myfn(cpy_r_m, cpy_r_k);")
def test_call_two_args(self) -> None:
self.assert_emit(Call(self.n, 'myfn', [self.m, self.k]),
"cpy_r_n = CPyDef_myfn(cpy_r_m, cpy_r_k);")
def test_call(self) -> None:
self.assert_emit(Call(self.n, 'myfn', [self.m]),
"cpy_r_n = CPyDef_myfn(cpy_r_m);")
def test_call_two_args(self) -> None:
self.assert_emit(Call(int_rprimitive, 'mod.myfn', [self.m, self.k], 55),
"cpy_r_r0 = CPyDef_myfn(cpy_r_m, cpy_r_k);")
def test_call(self) -> None:
self.assert_emit(Call(int_rprimitive, 'mod.myfn', [self.m], 55),
"cpy_r_r0 = CPyDef_myfn(cpy_r_m);")