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_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: ast3.Return) -> ReturnStmt:
node = ReturnStmt(self.visit(n.value))
return self.set_line(node, n)
