def get_wrapper_sig(self, act_as_func_def, is_dynamic):
"""Return the signature of the wrapper method.
The wrapper method signature has an additional type variable
argument (with type 'any'), and all type variables have been
erased.
"""
sig = function_type(act_as_func_def)
if is_dynamic:
return dynamic_sig(sig)
elif is_generic(act_as_func_def):
return erase_generic_types(sig) # FIX REFACTOR?
else:
return sig
def get_wrapper_sig(self, act_as_func_def: FuncDef,
is_dynamic: bool) -> Callable:
"""Return the signature of the wrapper method.
The wrapper method signature has an additional type variable
argument (with type 'Any'), and all type variables have been
erased.
"""
sig = cast(Callable, function_type(act_as_func_def))
if is_dynamic:
return dynamic_sig(sig)
elif is_generic(act_as_func_def):
return cast(Callable, erase_generic_types(sig)) # FIX REFACTOR?
else:
return sig
def get_call_sig(self, act_as_func_def: FuncDef, current_class: TypeInfo,
is_dynamic: bool, is_wrapper_class: bool,
is_override: bool) -> Callable:
"""Return the source signature in a wrapped call.
It has type variables replaced with 'Any', but as an
exception, type variables are intact in the return type in
generic wrapper classes. The exception allows omitting an
extra return value coercion, as the target return type and the
source return type will be the same.
"""
sig = cast(Callable, function_type(act_as_func_def))
if is_dynamic:
return dynamic_sig(sig)
elif is_generic(act_as_func_def):
call_sig = sig
# If this is an override wrapper, keep type variables
# intact. Otherwise replace them with dynamic to get
# desired coercions that check argument types.
if not is_override or is_wrapper_class:
call_sig = (cast(Callable, replace_type_vars(call_sig, False)))
else:
call_sig = cast(
Callable,
map_type_from_supertype(call_sig, current_class,
act_as_func_def.info))
if is_wrapper_class:
# Replace return type with the original return within
# wrapper classes to get rid of an unnecessary
# coercion. There will still be a coercion due to the
# extra coercion generated for generic wrapper
# classes. However, function generic type variables
# still need to be replaced, as the wrapper does not
# affect them.
ret = sig.ret_type
if is_dynamic:
ret = translate_function_type_vars_to_dynamic(ret)
call_sig = replace_ret_type(
call_sig, translate_type_vars_to_wrapper_vars(ret))
return call_sig
else:
return sig
def get_call_sig(self, act_as_func_def: FuncDef,
current_class: TypeInfo, is_dynamic: bool,
is_wrapper_class: bool, is_override: bool) -> Callable:
"""Return the source signature in a wrapped call.
It has type variables replaced with 'Any', but as an
exception, type variables are intact in the return type in
generic wrapper classes. The exception allows omitting an
extra return value coercion, as the target return type and the
source return type will be the same.
"""
sig = cast(Callable, function_type(act_as_func_def))
if is_dynamic:
return dynamic_sig(sig)
elif is_generic(act_as_func_def):
call_sig = sig
# If this is an override wrapper, keep type variables
# intact. Otherwise replace them with dynamic to get
# desired coercions that check argument types.
if not is_override or is_wrapper_class:
call_sig = (cast(Callable, replace_type_vars(call_sig, False)))
else:
call_sig = cast(Callable, map_type_from_supertype(
call_sig, current_class, act_as_func_def.info))
if is_wrapper_class:
# Replace return type with the original return within
# wrapper classes to get rid of an unnecessary
# coercion. There will still be a coercion due to the
# extra coercion generated for generic wrapper
# classes. However, function generic type variables
# still need to be replaced, as the wrapper does not
# affect them.
ret = sig.ret_type
if is_dynamic:
ret = translate_function_type_vars_to_dynamic(ret)
call_sig = replace_ret_type(
call_sig, translate_type_vars_to_wrapper_vars(ret))
return call_sig
else:
return sig
return (Callable)translate_function_type_vars_to_dynamic(sig)
else:
return sig
else:
return sig
Callable get_wrapper_sig(self, FuncDef act_as_func_def, bool is_dynamic):
"""Return the signature of the wrapper method.
The wrapper method signature has an additional type variable
argument (with type 'any'), and all type variables have been
erased.
"""
sig = (Callable)function_type(act_as_func_def)
if is_dynamic:
return dynamic_sig(sig)
elif is_generic(act_as_func_def):
return (Callable)erase_generic_types(sig) # FIX REFACTOR?
else:
return sig
Callable get_call_sig(self, FuncDef act_as_func_def,
TypeInfo current_class, bool is_dynamic,
bool is_wrapper_class, bool is_override):
"""Return the source signature in a wrapped call.
It has type variables replaced with 'any', but as an
exception, type variables are intact in the return type in
generic wrapper classes. The exception allows omitting an
extra return value coercion, as the target return type and the
source return type will be the same.