more comments

Author: mtshiba

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -248,7 +248,10 @@ def f(x: IntOr, y: OrInt):
 # error: [cyclic-type-alias-definition] "Cyclic definition of `Itself`"
 type Itself = Itself
 
-def foo(Itself: Itself):
+def foo(
+    # this is a very strange thing to do, but this is a regression test to ensure it doesn't panic
+    Itself: Itself,
+):
     x: Itself
     reveal_type(Itself)  # revealed: Divergent
 
@@ -271,6 +274,9 @@ type G[T] = G[T]
 type H[T] = I[T]
 # error: [cyclic-type-alias-definition] "Cyclic definition of `I`"
 type I[T] = H[T]
+
+# It's not possible to create an element of this type, but it's not an error for now
+type DirectRecursiveList[T] = list[DirectRecursiveList[T]]
 ```
 
 ### With legacy generic

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

@@ -1903,7 +1903,18 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             self.infer_annotation_expression(&type_alias.value, DeferredExpressionState::None);
 
         // A type alias where a value type points to itself, i.e. the expanded type is `Divergent` is meaningless
+        // (but a type alias that expands to something like `list[Divergent]` may be a valid recursive type alias)
         // and would lead to infinite recursion. Therefore, such type aliases should not be exposed.
+        // ```python
+        // type Itself = Itself  # error: "Cyclic definition of `Itself`"
+        // type A = B  # error: "Cyclic definition of `A`"
+        // type B = A  # error: "Cyclic definition of `B`"
+        // type G[T] = G[T]  # error: "Cyclic definition of `G`"
+        // type RecursiveList[T] = list[T | RecursiveList[T]]  # OK
+        // type RecursiveList2[T] = list[RecursiveList2[T]]  # It's not possible to create an element of this, but it's not an error for now
+        // type IntOrStr = int | StrOrInt  # It's redundant, but OK for now
+        // type StrOrInt = str | IntOrStr  # It's redundant, but OK for now
+        // ```
         let expanded = value_ty.inner_type().expand_eagerly(self.db());
         if expanded.is_divergent() {
             if let Some(builder) = self