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)