now disjoint base

Author: JelleZijlstra

doc/index.rst

@@ -705,6 +705,17 @@ Decorators
       Inheriting from a deprecated class now also raises a runtime
       :py:exc:`DeprecationWarning`.
 
+.. decorator:: disjoint_base
+
+   See :pep:`800`. A class decorator that marks a class as a "disjoint base", meaning that
+   child classes of the decorated class cannot inherit from other disjoint bases that are not
+   parent classes of the decorated class.
+
+   This helps type checkers to detect unreachable code and to understand when two types
+   can overlap.
+
+   .. versionadded:: 4.15.0
+
 .. decorator:: final
 
    See :py:func:`typing.final` and :pep:`591`. In ``typing`` since 3.8.
@@ -748,17 +759,6 @@ Decorators
    improved, and ``typing_extensions`` backports these performance
    improvements.
 
-.. decorator:: solid_base
-
-   See :pep:`800`. A class decorator that marks a class as a "solid base", meaning that
-   child classes of the decorated class cannot inherit from other solid bases that are not
-   parent classes of the decorated class.
-
-   This helps type checkers to detect unreachable code and to understand when two types
-   can overlap.
-
-   .. versionadded:: 4.15.0
-
 Functions
 ~~~~~~~~~
 

src/test_typing_extensions.py

@@ -84,6 +84,7 @@
     clear_overloads,
     dataclass_transform,
     deprecated,
+    disjoint_base,
     evaluate_forward_ref,
     final,
     get_annotations,
@@ -101,7 +102,6 @@
     reveal_type,
     runtime,
     runtime_checkable,
-    solid_base,
     type_repr,
 )
 
@@ -6671,16 +6671,16 @@ def cached(self): ...
         self.assertIs(True, Methods.cached.__final__)
 
 
-class SolidBaseTests(BaseTestCase):
-    def test_solid_base_unmodified(self):
+class DisjointBaseTests(BaseTestCase):
+    def test_disjoint_base_unmodified(self):
         class C: ...
-        self.assertIs(C, solid_base(C))
+        self.assertIs(C, disjoint_base(C))
 
-    def test_dunder_solid_base(self):
-        @solid_base
+    def test_dunder_disjoint_base(self):
+        @disjoint_base
         class C: ...
 
-        self.assertIs(C.__solid_base__, True)
+        self.assertIs(C.__disjoint_base__, True)
 
 
 class RevealTypeTests(BaseTestCase):

src/typing_extensions.py

@@ -71,6 +71,7 @@
     'clear_overloads',
     'dataclass_transform',
     'deprecated',
+    'disjoint_base',
     'Doc',
     'evaluate_forward_ref',
     'get_overloads',
@@ -94,7 +95,6 @@
     'reveal_type',
     'runtime',
     'runtime_checkable',
-    'solid_base',
     'Text',
     'TypeAlias',
     'TypeAliasType',
@@ -322,30 +322,30 @@ class Other(Leaf):  # Error reported by type checker
         return f
 
 
-if hasattr(typing, "solid_base"):  # 3.15
-    solid_base = typing.solid_base
+if hasattr(typing, "disjoint_base"):  # 3.15
+    disjoint_base = typing.disjoint_base
 else:
-    def solid_base(cls):
-        """This decorator marks a class a solid base.
+    def disjoint_base(cls):
+        """This decorator marks a class as a disjoint base.
 
-        Child classes of a solid base cannot inherit from other solid bases that are
-        not parent classes of the solid base.
+        Child classes of a disjoint base cannot inherit from other disjoint bases that are
+        not parent classes of the disjoint base.
 
         For example:
 
-            @solid_base
-            class Solid1: pass
+            @disjoint_base
+            class Disjoint1: pass
 
-            @solid_base
-            class Solid2: pass
+            @disjoint_base
+            class Disjoint2: pass
 
-            class Solid3(Solid1, Solid2): pass  # Type checker error
+            class Disjoint3(Disjoint1, Disjoint2): pass  # Type checker error
 
-        Type checkers can use knowledge of solid bases to detect unreachable code
+        Type checkers can use knowledge of disjoint bases to detect unreachable code
         and determine when two types can overlap.
 
         See PEP 800."""
-        cls.__solid_base__ = True
+        cls.__disjoint_base__ = True
         return cls