Detect inferred args that don't satisfy bound/constraints

dcreager · dcreager · commit 8e78adcbb5f4 · 2025-04-28T21:17:07.000-04:00
diff --git a/crates/red_knot_python_semantic/resources/mdtest/generics/functions.md b/crates/red_knot_python_semantic/resources/mdtest/generics/functions.md
@@ -71,6 +71,39 @@ def f[T](x: list[T]) -> T:
 reveal_type(f([1.0, 2.0]))  # revealed: Unknown
 ```
 
+## Inferring a bound typevar
+
+<!-- snapshot-diagnostics -->
+
+```py
+from typing_extensions import reveal_type
+
+def f[T: int](x: T) -> T:
+    return x
+
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f(True))  # revealed: Literal[True]
+# error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper bound of type variable `T`"
+reveal_type(f("string"))  # revealed: Unknown
+```
+
+## Inferring a constrained typevar
+
+<!-- snapshot-diagnostics -->
+
+```py
+from typing_extensions import reveal_type
+
+def f[T: (int, None)](x: T) -> T:
+    return x
+
+reveal_type(f(1))  # revealed: int
+reveal_type(f(True))  # revealed: int
+reveal_type(f(None))  # revealed: None
+# error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constraints of type variable `T`"
+reveal_type(f("string"))  # revealed: Unknown
+```
+
 ## Typevar constraints
 
 If a type parameter has an upper bound, that upper bound constrains which types can be used for that
diff --git a/crates/red_knot_python_semantic/resources/mdtest/snapshots/functions.md_-_Generic_functions_-_Inferring_a_bound_typevar.snap b/crates/red_knot_python_semantic/resources/mdtest/snapshots/functions.md_-_Generic_functions_-_Inferring_a_bound_typevar.snap
@@ -0,0 +1,86 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: functions.md - Generic functions - Inferring a bound typevar
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/generics/functions.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | from typing_extensions import reveal_type
+2 | 
+3 | def f[T: int](x: T) -> T:
+4 |     return x
+5 | 
+6 | reveal_type(f(1))  # revealed: Literal[1]
+7 | reveal_type(f(True))  # revealed: Literal[True]
+8 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper bound of type variable `T`"
+9 | reveal_type(f("string"))  # revealed: Unknown
+```
+
+# Diagnostics
+
+```
+info: revealed-type: Revealed type
+ --> src/mdtest_snippet.py:6:1
+  |
+4 |     return x
+5 |
+6 | reveal_type(f(1))  # revealed: Literal[1]
+  | ^^^^^^^^^^^^^^^^^ `Literal[1]`
+7 | reveal_type(f(True))  # revealed: Literal[True]
+8 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper bo...
+  |
+
+```
+
+```
+info: revealed-type: Revealed type
+ --> src/mdtest_snippet.py:7:1
+  |
+6 | reveal_type(f(1))  # revealed: Literal[1]
+7 | reveal_type(f(True))  # revealed: Literal[True]
+  | ^^^^^^^^^^^^^^^^^^^^ `Literal[True]`
+8 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper b...
+9 | reveal_type(f("string"))  # revealed: Unknown
+  |
+
+```
+
+```
+error: lint:invalid-argument-type: Argument to this function is incorrect
+ --> src/mdtest_snippet.py:9:15
+  |
+7 | reveal_type(f(True))  # revealed: Literal[True]
+8 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper b...
+9 | reveal_type(f("string"))  # revealed: Unknown
+  |               ^^^^^^^^ Argument type `Literal["string"]` does not satisfy upper bound of type variable `T`
+  |
+info: Type variable defined here
+ --> src/mdtest_snippet.py:3:7
+  |
+1 | from typing_extensions import reveal_type
+2 |
+3 | def f[T: int](x: T) -> T:
+  |       ^^^^^^
+4 |     return x
+  |
+
+```
+
+```
+info: revealed-type: Revealed type
+ --> src/mdtest_snippet.py:9:1
+  |
+7 | reveal_type(f(True))  # revealed: Literal[True]
+8 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy upper b...
+9 | reveal_type(f("string"))  # revealed: Unknown
+  | ^^^^^^^^^^^^^^^^^^^^^^^^ `Unknown`
+  |
+
+```
diff --git a/crates/red_knot_python_semantic/resources/mdtest/snapshots/functions.md_-_Generic_functions_-_Inferring_a_constrained_typevar.snap b/crates/red_knot_python_semantic/resources/mdtest/snapshots/functions.md_-_Generic_functions_-_Inferring_a_constrained_typevar.snap
@@ -0,0 +1,101 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: functions.md - Generic functions - Inferring a constrained typevar
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/generics/functions.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+ 1 | from typing_extensions import reveal_type
+ 2 | 
+ 3 | def f[T: (int, None)](x: T) -> T:
+ 4 |     return x
+ 5 | 
+ 6 | reveal_type(f(1))  # revealed: int
+ 7 | reveal_type(f(True))  # revealed: int
+ 8 | reveal_type(f(None))  # revealed: None
+ 9 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constraints of type variable `T`"
+10 | reveal_type(f("string"))  # revealed: Unknown
+```
+
+# Diagnostics
+
+```
+info: revealed-type: Revealed type
+ --> src/mdtest_snippet.py:6:1
+  |
+4 |     return x
+5 |
+6 | reveal_type(f(1))  # revealed: int
+  | ^^^^^^^^^^^^^^^^^ `int`
+7 | reveal_type(f(True))  # revealed: int
+8 | reveal_type(f(None))  # revealed: None
+  |
+
+```
+
+```
+info: revealed-type: Revealed type
+ --> src/mdtest_snippet.py:7:1
+  |
+6 | reveal_type(f(1))  # revealed: int
+7 | reveal_type(f(True))  # revealed: int
+  | ^^^^^^^^^^^^^^^^^^^^ `int`
+8 | reveal_type(f(None))  # revealed: None
+9 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constra...
+  |
+
+```
+
+```
+info: revealed-type: Revealed type
+  --> src/mdtest_snippet.py:8:1
+   |
+ 6 | reveal_type(f(1))  # revealed: int
+ 7 | reveal_type(f(True))  # revealed: int
+ 8 | reveal_type(f(None))  # revealed: None
+   | ^^^^^^^^^^^^^^^^^^^^ `None`
+ 9 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constra...
+10 | reveal_type(f("string"))  # revealed: Unknown
+   |
+
+```
+
+```
+error: lint:invalid-argument-type: Argument to this function is incorrect
+  --> src/mdtest_snippet.py:10:15
+   |
+ 8 | reveal_type(f(None))  # revealed: None
+ 9 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constra...
+10 | reveal_type(f("string"))  # revealed: Unknown
+   |               ^^^^^^^^ Argument type `Literal["string"]` does not satisfy constraints of type variable `T`
+   |
+info: Type variable defined here
+ --> src/mdtest_snippet.py:3:7
+  |
+1 | from typing_extensions import reveal_type
+2 |
+3 | def f[T: (int, None)](x: T) -> T:
+  |       ^^^^^^^^^^^^^^
+4 |     return x
+  |
+
+```
+
+```
+info: revealed-type: Revealed type
+  --> src/mdtest_snippet.py:10:1
+   |
+ 8 | reveal_type(f(None))  # revealed: None
+ 9 | # error: [invalid-argument-type] "Argument to this function is incorrect: Argument type `Literal["string"]` does not satisfy constra...
+10 | reveal_type(f("string"))  # revealed: Unknown
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ `Unknown`
+   |
+
+```
diff --git a/crates/red_knot_python_semantic/src/types/call/bind.rs b/crates/red_knot_python_semantic/src/types/call/bind.rs
@@ -16,7 +16,7 @@ use crate::types::diagnostic::{
     NO_MATCHING_OVERLOAD, PARAMETER_ALREADY_ASSIGNED, TOO_MANY_POSITIONAL_ARGUMENTS,
     UNKNOWN_ARGUMENT,
 };
-use crate::types::generics::{Specialization, SpecializationBuilder};
+use crate::types::generics::{Specialization, SpecializationBuilder, SpecializationError};
 use crate::types::signatures::{Parameter, ParameterForm};
 use crate::types::{
     todo_type, BoundMethodType, DataclassParams, DataclassTransformerParams, FunctionDecorators,
@@ -1172,12 +1172,28 @@ impl<'db> Binding<'db> {
         signature: &Signature<'db>,
         argument_types: &CallArgumentTypes<'_, 'db>,
     ) {
+        let mut num_synthetic_args = 0;
+        let get_argument_index = |argument_index: usize, num_synthetic_args: usize| {
+            if argument_index >= num_synthetic_args {
+                // Adjust the argument index to skip synthetic args, which don't appear at the call
+                // site and thus won't be in the Call node arguments list.
+                Some(argument_index - num_synthetic_args)
+            } else {
+                // we are erroring on a synthetic argument, we'll just emit the diagnostic on the
+                // entire Call node, since there's no argument node for this argument at the call site
+                None
+            }
+        };
+
         // If this overload is generic, first see if we can infer a specialization of the function
         // from the arguments that were passed in.
         let parameters = signature.parameters();
         if signature.generic_context.is_some() || signature.inherited_generic_context.is_some() {
             let mut builder = SpecializationBuilder::new(db);
-            for (argument_index, (_, argument_type)) in argument_types.iter().enumerate() {
+            for (argument_index, (argument, argument_type)) in argument_types.iter().enumerate() {
+                if matches!(argument, Argument::Synthetic) {
+                    num_synthetic_args += 1;
+                }
                 let Some(parameter_index) = self.argument_parameters[argument_index] else {
                     // There was an error with argument when matching parameters, so don't bother
                     // type-checking it.
@@ -1187,26 +1203,20 @@ impl<'db> Binding<'db> {
                 let Some(expected_type) = parameter.annotated_type() else {
                     continue;
                 };
-                builder.infer(expected_type, argument_type);
+                if let Err(error) = builder.infer(expected_type, argument_type) {
+                    self.errors.push(BindingError::SpecializationError {
+                        error,
+                        argument_index: get_argument_index(argument_index, num_synthetic_args),
+                    });
+                }
             }
             self.specialization = signature.generic_context.map(|gc| builder.build(gc));
             self.inherited_specialization = signature
                 .inherited_generic_context
                 .map(|gc| builder.build(gc));
         }
 
-        let mut num_synthetic_args = 0;
-        let get_argument_index = |argument_index: usize, num_synthetic_args: usize| {
-            if argument_index >= num_synthetic_args {
-                // Adjust the argument index to skip synthetic args, which don't appear at the call
-                // site and thus won't be in the Call node arguments list.
-                Some(argument_index - num_synthetic_args)
-            } else {
-                // we are erroring on a synthetic argument, we'll just emit the diagnostic on the
-                // entire Call node, since there's no argument node for this argument at the call site
-                None
-            }
-        };
+        num_synthetic_args = 0;
         for (argument_index, (argument, argument_type)) in argument_types.iter().enumerate() {
             if matches!(argument, Argument::Synthetic) {
                 num_synthetic_args += 1;
@@ -1434,6 +1444,11 @@ pub(crate) enum BindingError<'db> {
         argument_index: Option<usize>,
         parameter: ParameterContext,
     },
+    /// An inferred specialization was invalid.
+    SpecializationError {
+        error: SpecializationError<'db>,
+        argument_index: Option<usize>,
+    },
     /// The call itself might be well constructed, but an error occurred while evaluating the call.
     /// We use this variant to report errors in `property.__get__` and `property.__set__`, which
     /// can occur when the call to the underlying getter/setter fails.
@@ -1546,6 +1561,35 @@ impl<'db> BindingError<'db> {
                 }
             }
 
+            Self::SpecializationError {
+                error,
+                argument_index,
+            } => {
+                let range = Self::get_node(node, *argument_index);
+                let Some(builder) = context.report_lint(&INVALID_ARGUMENT_TYPE, range) else {
+                    return;
+                };
+
+                let typevar = error.typevar();
+                let argument_type = error.argument_type();
+                let argument_ty_display = argument_type.display(context.db());
+
+                let mut diag = builder.into_diagnostic("Argument to this function is incorrect");
+                diag.set_primary_message(format_args!(
+                    "Argument type `{argument_ty_display}` does not satisfy {} of type variable `{}`",
+                    match error {
+                        SpecializationError::MismatchedBound {..} => "upper bound",
+                        SpecializationError::MismatchedConstraint {..} => "constraints",
+                    },
+                    typevar.name(context.db()),
+                ));
+
+                let typevar_range = typevar.definition(context.db()).full_range(context.db());
+                let mut sub = SubDiagnostic::new(Severity::Info, "Type variable defined here");
+                sub.annotate(Annotation::primary(typevar_range.into()));
+                diag.sub(sub);
+            }
+
             Self::InternalCallError(reason) => {
                 let node = Self::get_node(node, None);
                 if let Some(builder) = context.report_lint(&CALL_NON_CALLABLE, node) {
diff --git a/crates/red_knot_python_semantic/src/types/generics.rs b/crates/red_knot_python_semantic/src/types/generics.rs
