[ty] Don't require default typevars when specializing (#17872)

If a typevar is declared as having a default, we shouldn't require a
type to be specified for that typevar when explicitly specializing a
generic class:

```py
class WithDefault[T, U = int]: ...

reveal_type(WithDefault[str]())  # revealed: WithDefault[str, int]
```

---------

Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>

crates/ty_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -150,6 +150,17 @@ reveal_type(Constrained[int | str]())  # revealed: Constrained[int | str]
 reveal_type(Constrained[object]())  # revealed: Unknown
 ```
 
+If the type variable has a default, it can be omitted:
+
+```py
+WithDefaultU = TypeVar("WithDefaultU", default=int)
+
+class WithDefault(Generic[T, WithDefaultU]): ...
+
+reveal_type(WithDefault[str, str]())  # revealed: WithDefault[str, str]
+reveal_type(WithDefault[str]())  # revealed: WithDefault[str, int]
+```
+
 ## Inferring generic class parameters
 
 We can infer the type parameter from a type context:

crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md

@@ -133,6 +133,15 @@ reveal_type(Constrained[int | str]())  # revealed: Constrained[int | str]
 reveal_type(Constrained[object]())  # revealed: Unknown
 ```
 
+If the type variable has a default, it can be omitted:
+
+```py
+class WithDefault[T, U = int]: ...
+
+reveal_type(WithDefault[str, str]())  # revealed: WithDefault[str, str]
+reveal_type(WithDefault[str]())  # revealed: WithDefault[str, int]
+```
+
 ## Inferring generic class parameters
 
 We can infer the type parameter from a type context:

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

@@ -1316,10 +1316,27 @@ impl<'db> Binding<'db> {
         self.inherited_specialization
     }
 
+    /// Returns the bound types for each parameter, in parameter source order, or `None` if no
+    /// argument was matched to that parameter.
     pub(crate) fn parameter_types(&self) -> &[Option<Type<'db>>] {
         &self.parameter_tys
     }
 
+    /// Returns the bound types for each parameter, in parameter source order, with default values
+    /// applied for arguments that weren't matched to a parameter. Returns `None` if there are any
+    /// non-default arguments that weren't matched to a parameter.
+    pub(crate) fn parameter_types_with_defaults(
+        &self,
+        signature: &Signature<'db>,
+    ) -> Option<Box<[Type<'db>]>> {
+        signature
+            .parameters()
+            .iter()
+            .zip(&self.parameter_tys)
+            .map(|(parameter, parameter_ty)| parameter_ty.or(parameter.default_type()))
+            .collect()
+    }
+
     pub(crate) fn arguments_for_parameter<'a>(
         &'a self,
         argument_types: &'a CallArgumentTypes<'a, 'db>,

crates/ty_python_semantic/src/types/generics.rs

@@ -123,6 +123,9 @@ impl<'db> GenericContext<'db> {
             }
             None => {}
         }
+        if let Some(default_ty) = typevar.default_ty(db) {
+            parameter = parameter.with_default_type(default_ty);
+        }
         parameter
     }
 

crates/ty_python_semantic/src/types/infer.rs

@@ -6711,10 +6711,8 @@ impl<'db> TypeInferenceBuilder<'db> {
             }
             _ => CallArgumentTypes::positional([self.infer_type_expression(slice_node)]),
         };
-        let signatures = Signatures::single(CallableSignature::single(
+        let signature = generic_context.signature(self.db());
-            value_ty,
+        let signatures = Signatures::single(CallableSignature::single(value_ty, signature.clone()));
-            generic_context.signature(self.db()),
-        ));
         let bindings = match Bindings::match_parameters(signatures, &call_argument_types)
             .check_types(self.db(), &call_argument_types)
         {
@@ -6732,14 +6730,10 @@ impl<'db> TypeInferenceBuilder<'db> {
             .matching_overloads()
             .next()
             .expect("valid bindings should have matching overload");
-        let specialization = generic_context.specialize(
+        let parameters = overload
-            self.db(),
+            .parameter_types_with_defaults(&signature)
-            overload
+            .expect("matching overload should not have missing arguments");
-                .parameter_types()
+        let specialization = generic_context.specialize(self.db(), parameters);
-                .iter()
-                .map(|ty| ty.unwrap_or(Type::unknown()))
-                .collect(),
-        );
         Type::from(GenericAlias::new(self.db(), generic_class, specialization))
     }