Deprecate subclassing of Register and Bit

qiskit/circuit/bit.py

@@ -14,6 +14,7 @@
 Quantum bit and Classical bit objects.
 """
 import copy
+import warnings
 
 from qiskit.circuit.exceptions import CircuitError
 
@@ -57,6 +58,17 @@ def __init__(self, register=None, index=None):
             self._hash = hash((self._register, self._index))
             self._repr = f"{self.__class__.__name__}({self._register}, {self._index})"
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Bit' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     def __repr__(self):
         """Return the official string representing the bit."""
         if (self._register, self._index) == (None, None):

qiskit/circuit/register.py

@@ -17,7 +17,9 @@
 """
 
 from __future__ import annotations
+
 import itertools
+import warnings
 import numpy as np
 
 from qiskit.circuit.exceptions import CircuitError
@@ -125,6 +127,17 @@ def __init__(self, size: int | None = None, name: str | None = None, bits=None):
             # until first access.
             self._bit_indices = None
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Register' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     @property
     def name(self):
         """Get the register name."""

releasenotes/notes/deprecate-subclass-register-0ee4ab0b71c4bb4f.yaml

@@ -0,0 +1,9 @@
+---
+deprecations_circuits:
+  - |
+    It is now deprecated to subclass :class:`.Register` or :class:`.Bit`, or any subclass of them
+    (for example, :class:`.QuantumRegister` or :class:`~.circuit.Qubit`).  Subclassing these types
+    was never explicitly supported by Qiskit, and it is not clear precisely what the meaning would
+    be.  In Qiskit 2.0, the subclassing may become impossible due to technical limitations, and will
+    certainly not be stored in a circuit.  This is because of the move of the data model to Rust
+    space to improve performance.

test/python/circuit/test_bit.py

@@ -16,7 +16,7 @@
 import copy
 from unittest import mock
 
-from qiskit.circuit import bit
+from qiskit.circuit import bit, Qubit
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
@@ -76,6 +76,18 @@ def test_old_style_bit_copy(self):
 
         self.assertIs(bit1, bit2)
 
+    def test_deprecation_of_subclass(self):
+        """It's not permitted to subclass the objects."""
+        with self.assertWarnsRegex(DeprecationWarning, "subclassing 'Bit' is not supported"):
+
+            class _MyBit(bit.Bit):
+                """Direct subclass."""
+
+        with self.assertWarnsRegex(DeprecationWarning, "subclassing 'Bit' is not supported"):
+
+            class _MyQubit(Qubit):
+                """Indirect subclass."""
+
 
 class TestNewStyleBit(QiskitTestCase):
     """Test behavior of new-style bits."""

test/python/circuit/test_register.py

@@ -16,10 +16,7 @@
 
 from ddt import data, ddt
 
-from qiskit.circuit import bit
-from qiskit.circuit import QuantumRegister
-from qiskit.circuit import AncillaRegister
-from qiskit.circuit import ClassicalRegister
+from qiskit.circuit import bit, QuantumRegister, Register, AncillaRegister, ClassicalRegister
 from qiskit.circuit.exceptions import CircuitError
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
@@ -119,3 +116,15 @@ def test_newstyle_register_eq(self, reg_type):
         bits_difftype = [difftype.bit_type() for _ in range(3)]
         reg_difftype = difftype(name="foo", bits=bits_difftype)
         self.assertNotEqual(reg_difftype, test_reg)
+
+    def test_deprecation_of_subclass(self):
+        """It's not permitted to subclass the objects."""
+        with self.assertWarnsRegex(DeprecationWarning, "subclassing 'Register' is not supported"):
+
+            class _MyRegister(Register):
+                """Direct subclass."""
+
+        with self.assertWarnsRegex(DeprecationWarning, "subclassing 'Register' is not supported"):
+
+            class _MyQuantumRegister(QuantumRegister):
+                """Indirect subclass."""