add generator type inference as TODO

Author: mtshiba

Cargo.lock

@@ -209,6 +209,14 @@ def h(x: int, y: str):
         return y
 
 reveal_type(h(1, "a"))  # revealed: int | str | None
+
+def generator():
+    yield 1
+    yield 2
+    return None
+
+# TODO: Should be `Generator[Literal[1, 2], Any, None]`
+reveal_type(generator())  # revealed: None
 ```
 
 ## Invalid return type

crates/ty_python_semantic/resources/mdtest/function/return_type.md

@@ -4200,8 +4200,8 @@ impl<'db> Type<'db> {
     ) -> Result<Bindings<'db>, CallError<'db>> {
         let signatures = self.signatures(db);
         let inferred_return_ty = || self.inferred_return_type(db).unwrap_or(Type::unknown());
-        Bindings::match_parameters(signatures, inferred_return_ty, &mut argument_types)
-            .check_types(db, &mut argument_types)
+        Bindings::match_parameters(signatures, inferred_return_ty, argument_types)
+            .check_types(db, argument_types)
     }
 
     /// Look up a dunder method on the meta-type of `self` and call it.
@@ -4245,8 +4245,8 @@ impl<'db> Type<'db> {
                         .unwrap_or(Type::unknown())
                 };
                 let bindings =
-                    Bindings::match_parameters(signatures, inferred_return_ty, &mut argument_types)
-                        .check_types(db, &mut argument_types)?;
+                    Bindings::match_parameters(signatures, inferred_return_ty, argument_types)
+                        .check_types(db, argument_types)?;
                 if boundness == Boundness::PossiblyUnbound {
                     return Err(CallDunderError::PossiblyUnbound(Box::new(bindings)));
                 }
@@ -4489,6 +4489,7 @@ impl<'db> Type<'db> {
                     }
                 }
                 Symbol::Unbound => None,
+            }
         });
 
         // Construct an instance type that we can use to look up the `__init__` instance method.

crates/ty_python_semantic/src/types.rs

@@ -56,6 +56,7 @@ impl<'db> Bindings<'db> {
     /// verify that each argument type is assignable to the corresponding parameter type.
     pub(crate) fn match_parameters(
         signatures: Signatures<'db>,
+        inferred_return_ty: impl Fn() -> Type<'db> + Copy,
         arguments: &CallArguments<'_>,
     ) -> Self {
         let mut argument_forms = vec![None; arguments.len()];
@@ -68,6 +69,7 @@ impl<'db> Bindings<'db> {
                     arguments,
                     &mut argument_forms,
                     &mut conflicting_forms,
+                    inferred_return_ty,
                 )
             })
             .collect();
@@ -892,6 +894,7 @@ impl<'db> CallableBinding<'db> {
         arguments: &CallArguments<'_>,
         argument_forms: &mut [Option<ParameterForm>],
         conflicting_forms: &mut [bool],
+        inferred_return_ty: impl Fn() -> Type<'db> + Copy,
     ) -> Self {
         // If this callable is a bound method, prepend the self instance onto the arguments list
         // before checking.
@@ -911,6 +914,7 @@ impl<'db> CallableBinding<'db> {
                     arguments.as_ref(),
                     argument_forms,
                     conflicting_forms,
+                    inferred_return_ty,
                 )
             })
             .collect();
@@ -1079,6 +1083,7 @@ impl<'db> Binding<'db> {
         arguments: &CallArguments<'_>,
         argument_forms: &mut [Option<ParameterForm>],
         conflicting_forms: &mut [bool],
+        inferred_return_ty: impl Fn() -> Type<'db>,
     ) -> Self {
         let parameters = signature.parameters();
         // The parameter that each argument is matched with.
@@ -1195,7 +1200,7 @@ impl<'db> Binding<'db> {
         }
 
         Self {
-            return_ty: signature.return_ty.unwrap_or(Type::unknown()),
+            return_ty: signature.return_ty.unwrap_or_else(inferred_return_ty),
             specialization: None,
             inherited_specialization: None,
             argument_parameters: argument_parameters.into_boxed_slice(),

crates/ty_python_semantic/src/types/call/bind.rs

@@ -4701,9 +4701,8 @@ impl<'db> TypeInferenceBuilder<'db> {
                 .inferred_return_type(self.db())
                 .unwrap_or(Type::unknown())
         };
-        let bindings =
-            Bindings::match_parameters(signatures, inferred_return_ty, &mut call_arguments);
-        let mut call_argument_types =
+        let bindings = Bindings::match_parameters(signatures, inferred_return_ty, &call_arguments);
+        let call_argument_types =
             self.infer_argument_types(arguments, call_arguments, &bindings.argument_forms);
 
         match bindings.check_types(self.db(), &call_argument_types) {
@@ -6722,19 +6721,16 @@ impl<'db> TypeInferenceBuilder<'db> {
                 .inferred_return_type(self.db())
                 .unwrap_or(Type::unknown())
         };
-        let bindings = match Bindings::match_parameters(
-            signatures,
-            inferred_return_ty,
-            &mut call_argument_types,
-        )
-        .check_types(self.db(), &mut call_argument_types)
-        {
-            Ok(bindings) => bindings,
-            Err(CallError(_, bindings)) => {
-                bindings.report_diagnostics(&self.context, subscript.into());
-                return Type::unknown();
-            }
-        };
+        let bindings =
+            match Bindings::match_parameters(signatures, inferred_return_ty, &call_argument_types)
+                .check_types(self.db(), &call_argument_types)
+            {
+                Ok(bindings) => bindings,
+                Err(CallError(_, bindings)) => {
+                    bindings.report_diagnostics(&self.context, subscript.into());
+                    return Type::unknown();
+                }
+            };
         let callable = bindings
             .into_iter()
             .next()