Temp: Generics issue

Author: Glyphack

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -231,3 +231,27 @@ class MyMetaclass(type):
     def __new__(cls) -> Self:
         return super().__new__(cls)
 ```
+
+## Custom
+
+TODO: Just a random test I added for debugging.
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+class C(Generic[T]):
+    def __init__(self, x: T) -> None: ...
+
+# in the __init__ method self has type of C[Literal["five"]]
+C("five")
+```
+
+The argument self has type C[T] and then it is specialized to C\[Literal["five"]\]. But then the
+argument type is C[str]. One way they are assignable but not the other way around.

crates/ty_python_semantic/src/types.rs

@@ -4949,9 +4949,15 @@ impl<'db> Type<'db> {
                             ],
                         });
                     };
-                    let instance = Type::ClassLiteral(class)
-                        .to_instance(db)
-                        .expect("enclosing_class_symbol must return type that can be instantiated");
+                    let instance = match class.generic_context(db) {
+                        Some(generic_context) => {
+                            let specialization = generic_context.identity_specialization(db);
+                            Type::GenericAlias(GenericAlias::new(db, class, specialization))
+                        }
+                        _ => Type::ClassLiteral(class).to_instance(db).expect(
+                            "enclosing_class_symbol must return type that can be instantiated",
+                        ),
+                    };
                     Ok(Type::TypeVar(TypeVarInstance::new(
                         db,
                         ast::name::Name::new("Self"),

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

@@ -1409,6 +1409,7 @@ impl<'db> Binding<'db> {
                     });
                 }
             }
+            // dbg!(signature.generic_context);
             self.specialization = signature.generic_context.map(|gc| builder.build(gc));
             self.inherited_specialization = signature.inherited_generic_context.map(|gc| {
                 // The inherited generic context is used when inferring the specialization of a
@@ -1432,6 +1433,9 @@ impl<'db> Binding<'db> {
             };
             let parameter = &parameters[parameter_index];
             if let Some(mut expected_ty) = parameter.annotated_type() {
+                if parameter.name().is_some_and(|f| f == "self") {
+                    dbg!(parameter);
+                }
                 if let Some(specialization) = self.specialization {
                     argument_type = argument_type.apply_specialization(db, specialization);
                     expected_ty = expected_ty.apply_specialization(db, specialization);
@@ -1444,6 +1448,7 @@ impl<'db> Binding<'db> {
                 if !argument_type.is_assignable_to(db, expected_ty) {
                     let positional = matches!(argument, Argument::Positional | Argument::Synthetic)
                         && !parameter.is_variadic();
+                    dbg!("problem", argument_type, expected_ty);
                     self.errors.push(BindingError::InvalidArgumentType {
                         parameter: ParameterContext::new(parameter, parameter_index, positional),
                         argument_index: get_argument_index(argument_index, num_synthetic_args),

crates/ty_python_semantic/src/types/class.rs

@@ -402,6 +402,8 @@ impl<'db> ClassType<'db> {
                 ClassBase::Class(base) => match (base, other) {
                     (ClassType::NonGeneric(base), ClassType::NonGeneric(other)) => base == other,
                     (ClassType::Generic(base), ClassType::Generic(other)) => {
+                        // Here base has specialization Literal
+                        // dbg!(base);
                         base.origin(db) == other.origin(db)
                             && base
                                 .specialization(db)

crates/ty_python_semantic/src/types/generics.rs

@@ -9,7 +9,7 @@ use crate::types::class_base::ClassBase;
 use crate::types::instance::{NominalInstanceType, Protocol, ProtocolInstanceType};
 use crate::types::signatures::{Parameter, Parameters, Signature};
 use crate::types::{
-    KnownInstanceType, Type, TypeMapping, TypeVarBoundOrConstraints, TypeVarInstance,
+    KnownClass, KnownInstanceType, Type, TypeMapping, TypeVarBoundOrConstraints, TypeVarInstance,
     TypeVarVariance, UnionType, declaration_type, todo_type,
 };
 use crate::{Db, FxOrderSet};
@@ -448,6 +448,14 @@ impl<'db> Specialization<'db> {
             //   - bivariant: skip, can't make assignability false
             let compatible = match typevar.variance(db) {
                 TypeVarVariance::Invariant => {
+                    match self_type {
+                        Type::StringLiteral(_) => {
+                            dbg!(self_type, other_type);
+                            dbg!(self_type.is_assignable_to(db, *other_type));
+                            dbg!(other_type.is_assignable_to(db, *self_type));
+                        }
+                        _ => (),
+                    };
                     self_type.is_assignable_to(db, *other_type)
                         && other_type.is_assignable_to(db, *self_type)
                 }
@@ -561,6 +569,7 @@ impl<'db> SpecializationBuilder<'db> {
         }
     }
 
+    // Here we produce literal
     pub(crate) fn build(&mut self, generic_context: GenericContext<'db>) -> Specialization<'db> {
         let types: Box<[_]> = generic_context
             .variables(self.db)