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 transform_method_implementation(self, fdef, name): """Transform the implementation of a method (i.e. unwrapped).""" args = fdef.args arg_kinds = fdef.arg_kinds typ = function_type(fdef) init = fdef.init_expressions() if fdef.name() == '__init__' and is_generic(fdef): args, arg_kinds, init, typ = self.add_constructor_tvar_args( fdef, typ, args, arg_kinds, init) fdef2 = FuncDef(name, args, arg_kinds, init, fdef.body, typ) fdef2.info = fdef.info self.tf.prepend_generic_function_tvar_args(fdef2) return fdef2
def transform_method_implementation(self, fdef: FuncDef, name: str) -> FuncDef: """Transform the implementation of a method (i.e. unwrapped).""" args = fdef.args arg_kinds = fdef.arg_kinds typ = function_type(fdef) # type: Type init = fdef.init_expressions() if fdef.name() == '__init__' and is_generic(fdef): args, arg_kinds, init, typ = self.add_constructor_tvar_args( fdef, typ, args, arg_kinds, init) fdef2 = FuncDef(name, args, arg_kinds, init, fdef.body, typ) fdef2.info = fdef.info self.tf.prepend_generic_function_tvar_args(fdef2) return fdef2
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
# Not an override. # Create a dynamically-typed method wrapper. res.append(self.dynamic_method_wrapper(fdef)) return res FuncDef transform_method_implementation(self, FuncDef fdef, str name): """Transform the implementation of a method (i.e. unwrapped).""" args = fdef.args arg_kinds = fdef.arg_kinds Type typ = function_type(fdef) init = fdef.init_expressions() if fdef.name() == '__init__' and is_generic(fdef): args, arg_kinds, init, typ = self.add_constructor_tvar_args( fdef, typ, args, arg_kinds, init) fdef2 = FuncDef(name, args, arg_kinds, init, fdef.body, typ) fdef2.info = fdef.info self.tf.prepend_generic_function_tvar_args(fdef2) return fdef2 tuple<Var[], int[], Node[], Type> \ add_constructor_tvar_args( self, FuncDef fdef, Type typ, Var[] args, int[] arg_kinds, Node[] init):