def infer_function_type_arguments(callee_type: CallableType,
arg_types: List[Optional[Type]],
arg_kinds: List[int],
formal_to_actual: List[List[int]],
strict: bool = True) -> List[Type]:
"""Infer the type arguments of a generic function.
Return an array of lower bound types for the type variables -1 (at
index 0), -2 (at index 1), etc. A lower bound is None if a value
could not be inferred.
Arguments:
callee_type: the target generic function
arg_types: argument types at the call site (each optional; if None,
we are not considering this argument in the current pass)
arg_kinds: nodes.ARG_* values for arg_types
formal_to_actual: mapping from formal to actual variable indices
"""
# Infer constraints.
constraints = infer_constraints_for_callable(
callee_type, arg_types, arg_kinds, formal_to_actual)
# Solve constraints.
type_vars = callee_type.type_var_ids()
return solve_constraints(type_vars, constraints, strict)
def infer_function_type_arguments(callee_type: CallableType,
arg_types: List[Optional[Type]],
arg_kinds: List[int],
formal_to_actual: List[List[int]],
strict: bool = True) -> List[Type]:
"""Infer the type arguments of a generic function.
Return an array of lower bound types for the type variables -1 (at
index 0), -2 (at index 1), etc. A lower bound is None if a value
could not be inferred.
Arguments:
callee_type: the target generic function
arg_types: argument types at the call site (each optional; if None,
we are not considering this argument in the current pass)
arg_kinds: nodes.ARG_* values for arg_types
formal_to_actual: mapping from formal to actual variable indices
"""
# Infer constraints.
constraints = infer_constraints_for_callable(callee_type, arg_types,
arg_kinds, formal_to_actual)
# Solve constraints.
type_vars = callee_type.type_var_ids()
return solve_constraints(type_vars, constraints, strict)
def _infer_constraints(
self,
applied_args: List[FuncArg],
) -> _Constraints:
"""Creates mapping of ``typevar`` to real type that we already know."""
checker = self._ctx.api.expr_checker # type: ignore
kinds = [arg.kind for arg in applied_args]
exprs = [arg.expression(self._ctx.context) for arg in applied_args]
formal_to_actual = map_actuals_to_formals(
kinds,
[arg.name for arg in applied_args],
self._fallback.arg_kinds,
self._fallback.arg_names,
lambda index: checker.accept(exprs[index]),
)
constraints = infer_constraints_for_callable(
self._fallback,
[arg.type for arg in applied_args],
kinds,
formal_to_actual,
)
return {
constraint.type_var: constraint.target
for constraint in constraints
}
def infer_function_type_arguments(callee_type: Callable,
arg_types: List[Type],
arg_kinds: List[int],
formal_to_actual: List[List[int]],
basic: BasicTypes) -> List[Type]:
"""Infer the type arguments of a generic function.
Return an array of lower bound types for the type variables -1 (at
index 0), -2 (at index 1), etc. A lower bound is None if a value
could not be inferred.
Arguments:
callee_type: the target generic function
arg_types: argument types at the call site
arg_kinds: nodes.ARG_* values for arg_types
formal_to_actual: mapping from formal to actual variable indices
basic: references to basic types which are needed during inference
"""
# Infer constraints.
constraints = infer_constraints_for_callable(
callee_type, arg_types, arg_kinds, formal_to_actual)
# Solve constraints.
type_vars = callee_type.type_var_ids()
return solve_constraints(type_vars, constraints, basic)
BasicTypes basic):
"""Infer the type arguments of a generic function.
Return an array of lower bound types for the type variables -1 (at
index 0), -2 (at index 1), etc. A lower bound is None if a value
could not be inferred.
Arguments:
callee_type: the target generic function
arg_types: argument types at the call site
arg_kinds: nodes.ARG_* values for arg_types
formal_to_actual: mapping from formal to actual variable indices
basic: references to basic types which are needed during inference
"""
# Infer constraints.
constraints = infer_constraints_for_callable(
callee_type, arg_types, arg_kinds, formal_to_actual)
# Solve constraints.
type_vars = callee_type.type_var_ids()
return solve_constraints(type_vars, constraints, basic)
Type[] infer_type_arguments(int[] type_var_ids,
Type template, Type actual,
BasicTypes basic):
# Like infer_function_type_arguments, but only match a single type
# against a generic type.
constraints = infer_constraints(template, actual, SUBTYPE_OF)
return solve_constraints(type_var_ids, constraints, basic)