Workaround for numpy problem

Author: sharkdp

crates/ty_python_semantic/resources/mdtest/libraries/numpy.md

@@ -0,0 +1,64 @@
+# numpy
+
+```toml
+[environment]
+python-version = "3.14"
+```
+
+## numpy's `dtype`
+
+numpy functions often accept a `dtype` parameter. For example, one of `np.array`'s overloads accepts
+a `dtype` parameter of type `DTypeLike | None`. Here, we build up something that resembles numpy's
+internals in order to model the type `DTypeLike`. Many details have been left out.
+
+`mini_numpy.py`:
+
+```py
+from typing import TypeVar, Generic, Any, Protocol, TypeAlias, runtime_checkable, final
+import builtins
+
+_ItemT_co = TypeVar("_ItemT_co", default=Any, covariant=True)
+
+class generic(Generic[_ItemT_co]):
+    @property
+    def dtype(self) -> _DTypeT_co:
+        raise NotImplementedError
+
+_BoolItemT_co = TypeVar("_BoolItemT_co", bound=builtins.bool, default=builtins.bool, covariant=True)
+
+class bool(generic[_BoolItemT_co], Generic[_BoolItemT_co]): ...
+
+@final
+class object_(generic): ...
+
+_ScalarT = TypeVar("_ScalarT", bound=generic)
+_ScalarT_co = TypeVar("_ScalarT_co", bound=generic, default=Any, covariant=True)
+
+@final
+class dtype(Generic[_ScalarT_co]): ...
+
+_DTypeT_co = TypeVar("_DTypeT_co", bound=dtype, default=dtype, covariant=True)
+
+@runtime_checkable
+class _SupportsDType(Protocol[_DTypeT_co]):
+    @property
+    def dtype(self) -> _DTypeT_co: ...
+
+_DTypeLike: TypeAlias = type[_ScalarT] | dtype[_ScalarT] | _SupportsDType[dtype[_ScalarT]]
+
+DTypeLike: TypeAlias = _DTypeLike[Any] | str | None
+```
+
+Now we can make sure that a function which accepts `DTypeLike | None` works as expected:
+
+```py
+import mini_numpy as np
+
+def accepts_dtype(dtype: np.DTypeLike | None) -> None: ...
+
+accepts_dtype(dtype=np.bool)
+accepts_dtype(dtype=np.dtype[np.bool])
+accepts_dtype(dtype=object)
+accepts_dtype(dtype=np.object_)
+accepts_dtype(dtype="U")
+```

crates/ty_python_semantic/resources/mdtest/type_of/generics.md

@@ -163,7 +163,8 @@ def _[T: int](_: T):
     static_assert(is_assignable_to(type[T], Callable[..., T]))
     static_assert(not is_disjoint_from(type[T], Callable[..., T]))
 
-    static_assert(is_assignable_to(type[T], IntCallback))
+    # TODO: No error here.
+    static_assert(is_assignable_to(type[T], IntCallback))  # error: [static-assert-error]
     static_assert(not is_disjoint_from(type[T], IntCallback))
 
     static_assert(is_subtype_of(type[T], type[T] | None))

crates/ty_python_semantic/src/types.rs

@@ -2465,6 +2465,33 @@ impl<'db> Type<'db> {
                 })
             }
 
+            // TODO: The following two branches are a temporary workaround to prevent an important union type
+            // in numpy's internals from collapsing to a single type, which causes thousands of downstream
+            // false positive diagnostics across the ecosytem.
+            (Type::SubclassOf(self_subclass_ty), Type::ProtocolInstance(_))
+                if self_subclass_ty.is_type_var() =>
+            {
+                ConstraintSet::from(false)
+            }
+            (Type::SubclassOf(self_subclass_ty), Type::ProtocolInstance(_))
+                if self_subclass_ty.is_dynamic() =>
+            {
+                match relation {
+                    TypeRelation::Assignability => {
+                        // type[Dynamic] has arbitrary attributes, so it satisfies all protocols.
+                        ConstraintSet::from(true)
+                    }
+                    _ => KnownClass::Type.to_instance(db).has_relation_to_impl(
+                        db,
+                        target,
+                        inferable,
+                        relation,
+                        relation_visitor,
+                        disjointness_visitor,
+                    ),
+                }
+            }
+
             (_, Type::ProtocolInstance(protocol)) => {
                 relation_visitor.visit((self, target, relation), || {
                     self.satisfies_protocol(