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);")