def call_wrapper(self, fdef: FuncDef, is_dynamic: bool, is_wrapper_class: bool, target_ann: Callable, cur_ann: Callable, target_suffix: str, bound_sig: Callable) -> Node: """Return the body of wrapper method. The body contains only a call to the wrapped method and a return statement (if the call returns a value). Arguments are coerced to the target signature. """ args = self.call_args(fdef.args, target_ann, cur_ann, is_dynamic, is_wrapper_class, bound_sig, ismethod=fdef.is_method()) selfarg = args[0] args = args[1:] member = fdef.name() + target_suffix if not is_wrapper_class: callee = MemberExpr(selfarg, member) else: callee = MemberExpr( MemberExpr(self_expr(), self.tf.object_member_name()), member) call = CallExpr(callee, args, [nodes.ARG_POS] * len(args), [None] * len(args)) # type: Node if bound_sig: call = self.tf.coerce(call, bound_sig.ret_type, target_ann.ret_type, self.tf.type_context(), is_wrapper_class) call = self.tf.coerce(call, cur_ann.ret_type, bound_sig.ret_type, self.tf.type_context(), is_wrapper_class) else: call = self.tf.coerce(call, cur_ann.ret_type, target_ann.ret_type, self.tf.type_context(), is_wrapper_class) if not isinstance(target_ann.ret_type, Void): return ReturnStmt(call) else: return ExpressionStmt(call)
def make_type_object_wrapper(self, tdef: ClassDef) -> FuncDef: """Construct dynamically typed wrapper function for a class. It simple calls the type object and returns the result. """ # TODO keyword args, default args and varargs # TODO overloads type_sig = cast(Callable, type_object_type(tdef.info, None)) type_sig = cast(Callable, erasetype.erase_typevars(type_sig)) init = cast(FuncDef, tdef.info.get_method('__init__')) arg_kinds = type_sig.arg_kinds # The wrapper function has a dynamically typed signature. wrapper_sig = Callable( [AnyType()] * len(arg_kinds), arg_kinds, [None] * len(arg_kinds), AnyType(), False) n = NameExpr(tdef.name) # TODO full name args = self.func_tf.call_args( init.args[1:], type_sig, wrapper_sig, True, False) call = CallExpr(n, args, arg_kinds) ret = ReturnStmt(call) fdef = FuncDef(tdef.name + self.tf.dynamic_suffix(), init.args[1:], arg_kinds, [None] * len(arg_kinds), Block([ret])) fdef.type = wrapper_sig return fdef
def make_dynamic_getter_wrapper(self, name: str, typ: Type) -> FuncDef: """Create a dynamically-typed getter wrapper for a data attribute. The getter will be of this form: . def $name*(self: C) -> Any: . return {Any <= typ self.name!} """ scope = self.make_scope() selft = self.self_type() selfv = scope.add('self', selft) member_expr = MemberExpr(scope.name_expr('self'), name, direct=True) coerce_expr = coerce(member_expr, AnyType(), typ, self.tf.type_context()) ret = ReturnStmt(coerce_expr) wrapper_name = '$' + name + self.tf.dynamic_suffix() sig = Callable([selft], [nodes.ARG_POS], [None], AnyType(), False) return FuncDef(wrapper_name, [selfv], [nodes.ARG_POS], [None], Block([ret]), sig)
def make_getter_wrapper(self, name: str, typ: Type) -> FuncDef: """Create a getter wrapper for a data attribute. The getter will be of this form: . def $name*(self: C) -> type: . return self.name! """ scope = self.make_scope() selft = self.self_type() selfv = scope.add('self', selft) member_expr = MemberExpr(scope.name_expr('self'), name, direct=True) ret = ReturnStmt(member_expr) wrapper_name = '$' + name sig = Callable([selft], [nodes.ARG_POS], [None], typ, False) fdef = FuncDef(wrapper_name, [selfv], [nodes.ARG_POS], [None], Block([ret]), sig) fdef.info = self.tf.type_context() return fdef
def visit_Return(self, n: ast35.Return) -> Node: return ReturnStmt(self.visit(n.value))
def visit_Return(self, n: ast27.Return) -> ReturnStmt: stmt = ReturnStmt(self.visit(n.value)) return self.set_line(stmt, n)
def visit_Return(self, n: ast27.Return) -> ReturnStmt: return ReturnStmt(self.visit(n.value))
def visit_return_stmt(self, node: ReturnStmt) -> Node: return ReturnStmt(self.optional_node(node.expr))
def visit_return_stmt(self, node: ReturnStmt) -> ReturnStmt: return ReturnStmt(self.optional_expr(node.expr))
def visit_return_stmt(self, s: ReturnStmt) -> None: super().visit_return_stmt(s) s.expr = self.coerce(s.expr, self.return_types[-1], self.get_type(s.expr), self.type_context())
def visit_Return(self, n): return ReturnStmt(self.visit(n.value))
def visit_Return(self, n: ast3.Return) -> ReturnStmt: node = ReturnStmt(self.visit(n.value)) return self.set_line(node, n)