def infer_function_type_arguments_using_context(self, callable):
"""Unify callable return type to type context to infer type vars.
For example, if the return type is set<t> where 't' is a type variable
of callable, and if the context is set<int>, return callable modified
by substituting 't' with 'int'.
"""
ctx = self.chk.type_context[-1]
if not ctx:
return callable
# The return type may have references to function type variables that
# we are inferring right now. We must consider them as indeterminate
# and they are not potential results; thus we replace them with the
# None type. On the other hand, class type variables are valid results.
erased_ctx = replace_func_type_vars(ctx, ErasedType())
args = infer_type_arguments(callable.type_var_ids(), callable.ret_type,
erased_ctx, self.chk.basic_types())
# Only substite non-None and non-erased types.
new_args = []
for arg in args:
if isinstance(arg, NoneTyp) or has_erased_component(arg):
new_args.append(None)
else:
new_args.append(arg)
return self.apply_generic_arguments(callable, new_args, None)
Callable callable):
"""Unify callable return type to type context to infer type vars.
For example, if the return type is set<t> where 't' is a type variable
of callable, and if the context is set<int>, return callable modified
by substituting 't' with 'int'.
"""
ctx = self.chk.type_context[-1]
if not ctx:
return callable
# The return type may have references to function type variables that
# we are inferring right now. We must consider them as indeterminate
# and they are not potential results; thus we replace them with the
# None type. On the other hand, class type variables are valid results.
erased_ctx = replace_func_type_vars(ctx)
args = infer_type_arguments(callable.type_var_ids(), callable.ret_type,
erased_ctx, self.chk.basic_types())
# If all the inferred types are None types, do no type variable
# substition.
# TODO This is not nearly general enough. If a type has a None type
# component we should not use it. Also if some types are not-None
# we should only substitute them. Finally, using None types for
# this might not be optimal.
some_not_none = False
for i in range(len(args)):
if not isinstance(args[i], NoneTyp):
some_not_none = True
if not some_not_none:
return callable
return (Callable)self.apply_generic_arguments(callable, args, [], None)
Callable infer_function_type_arguments(self, Callable callee_type,
