wrapped optionals are covariant in their inner type

Author: KotlinIsland

crates/ty_python_semantic/resources/mdtest/basedpython_optional_type.md

@@ -69,6 +69,17 @@ def h() -> int???:
 reveal_type(h())  # revealed: int???
 ```
 
+## wrapped optionals are covariant in their inner type
+
+a narrower wrapped optional is assignable to a wider one — `Literal[1]??` to `int??`:
+
+```by
+def f[T](t: T) -> T??:
+    return Some(t)
+
+x: int?? = f(1)
+```
+
 ## force-unwrap `!` peels one optional layer
 
 `expr!` removes one layer of optionality: a wrapped optional yields the next layer in, and a plain

crates/ty_python_semantic/src/types/relation.rs

@@ -2062,6 +2062,14 @@ impl<'a, 'c, 'db> TypeRelationChecker<'a, 'c, 'db> {
                 self.check_type_pair(db, source_form.instance_fallback(db), target)
             }
 
+            // basedpython: wrapped optionals are covariant in their inner type —
+            // `Literal[1]??` is assignable to `int??` because every wrapped
+            // value of the former is a wrapped value of the latter
+            (
+                Type::KnownInstance(KnownInstanceType::WrappedOptional(source_inner)),
+                Type::KnownInstance(KnownInstanceType::WrappedOptional(target_inner)),
+            ) => self.check_type_pair(db, source_inner.inner(db), target_inner.inner(db)),
+
             // basedpython: a wrapped optional `WrappedOptional(inner)` accepts
             // any value of its decomposition `inner | None` — the wrapped value
             // itself, or `None` for the absent outer state. (Identical wrapped