ban double specialization

Author: mtshiba

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

@@ -80,12 +80,26 @@ def _(b: B[int]):
 type IntOrStr = int | str
 
 # error: [non-subscriptable] "Cannot subscript non-generic type alias"
-def _(c: IntOrStr[int]): ...
+def _(c: IntOrStr[int]):
+    reveal_type(c)  # revealed: Unknown
 
 type ListOfInts = list[int]
 
-# error: [non-subscriptable] "Cannot subscript non-generic type alias"
-def _(l: ListOfInts[int]): ...
+# error: [non-subscriptable] "Cannot subscript non-generic type alias: `list[int]` is already specialized"
+def _(l: ListOfInts[int]):
+    reveal_type(l)  # revealed: Unknown
+
+type List[T] = list[T]
+
+# error: [non-subscriptable] "Cannot subscript non-generic type alias: double specialization is not allowed"
+def _(l: List[int][int]):
+    reveal_type(l)  # revealed: Unknown
+
+# error: [non-subscriptable] "Cannot subscript non-generic type alias: `<class 'list[T@DoubleSpecialization]'>` is already specialized"
+type DoubleSpecialization[T] = list[T][T]
+
+def _(d: DoubleSpecialization[int]):
+    reveal_type(d)  # revealed: Unknown
 ```
 
 If the type variable has an upper bound, the specialized type must satisfy that bound:

crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md

@@ -653,12 +653,30 @@ def g(obj: Y[bool, range]):
 
 A generic alias that is already fully specialized cannot be specialized again:
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 ```py
 ListOfInts = list[int]
 
 # error: [non-subscriptable] "Cannot subscript non-generic type alias: `<class 'list[int]'>` is already specialized"
 def _(doubly_specialized: ListOfInts[int]):
     reveal_type(doubly_specialized)  # revealed: Unknown
+
+type ListOfInts2 = list[int]
+# error: [non-subscriptable] "Cannot subscript non-generic type alias: `list[int]` is already specialized"
+DoublySpecialized = ListOfInts2[int]
+
+def _(doubly_specialized: DoublySpecialized):
+    reveal_type(doubly_specialized)  # revealed: Unknown
+
+# error: [non-subscriptable] "Cannot subscript non-generic type alias: `<class 'list[int]'>` is already specialized"
+List = list[int][int]
+
+def _(doubly_specialized: List):
+    reveal_type(doubly_specialized)  # revealed: Unknown
 ```
 
 Specializing a generic implicit type alias with an incorrect number of type arguments also results

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -12069,9 +12069,19 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 Type::KnownInstance(KnownInstanceType::TypeAliasType(TypeAliasType::PEP695(alias))),
                 _,
             ) if alias.generic_context(db).is_none() => {
+                debug_assert!(alias.specialization(db).is_none());
                 if let Some(builder) = self.context.report_lint(&NON_SUBSCRIPTABLE, subscript) {
-                    builder
-                        .into_diagnostic(format_args!("Cannot subscript non-generic type alias"));
+                    let value_type = alias.raw_value_type(db);
+                    if value_type.is_generic_nominal_instance() {
+                        builder.into_diagnostic(format_args!(
+                            "Cannot subscript non-generic type alias: `{}` is already specialized",
+                            value_type.display(db),
+                        ));
+                    } else {
+                        builder.into_diagnostic(format_args!(
+                            "Cannot subscript non-generic type alias"
+                        ));
+                    }
                 }
 
                 Some(Type::unknown())

crates/ty_python_semantic/src/types/infer/builder/type_expression.rs

@@ -914,6 +914,16 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                     Type::unknown()
                 }
                 KnownInstanceType::TypeAliasType(type_alias @ TypeAliasType::PEP695(_)) => {
+                    if type_alias.specialization(self.db()).is_some() {
+                        if let Some(builder) =
+                            self.context.report_lint(&NON_SUBSCRIPTABLE, subscript)
+                        {
+                            builder.into_diagnostic(format_args!(
+                                "Cannot subscript non-generic type alias: double specialization is not allowed",
+                            ));
+                        }
+                        return Type::unknown();
+                    }
                     match type_alias.generic_context(self.db()) {
                         Some(generic_context) => {
                             let specialized_type_alias = self
@@ -938,9 +948,17 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                             if let Some(builder) =
                                 self.context.report_lint(&NON_SUBSCRIPTABLE, subscript)
                             {
-                                builder.into_diagnostic(format_args!(
-                                    "Cannot subscript non-generic type alias"
-                                ));
+                                let value_type = type_alias.raw_value_type(self.db());
+                                if value_type.is_generic_nominal_instance() {
+                                    builder.into_diagnostic(format_args!(
+                                        "Cannot subscript non-generic type alias: `{}` is already specialized",
+                                        value_type.display(self.db()),
+                                    ));
+                                } else {
+                                    builder.into_diagnostic(format_args!(
+                                        "Cannot subscript non-generic type alias"
+                                    ));
+                                }
                             }
 
                             Type::unknown()

crates/ty_python_semantic/src/types/instance.rs

@@ -93,6 +93,10 @@ impl<'db> Type<'db> {
         matches!(self, Type::NominalInstance(_))
     }
 
+    pub(crate) const fn is_generic_nominal_instance(self) -> bool {
+        matches!(self, Type::NominalInstance(instance_type) if matches!(instance_type.0, NominalInstanceInner::NonTuple(class) if class.is_generic()))
+    }
+
     pub(crate) const fn as_nominal_instance(self) -> Option<NominalInstanceType<'db>> {
         match self {
             Type::NominalInstance(instance_type) => Some(instance_type),