hdl: make ValueCastable.from_bits override mandatory.

Author: wanda-phi

amaranth/hdl/_ast.py

@@ -253,9 +253,8 @@ def __init_subclass__(cls, **kwargs):
             raise TypeError(f"Class '{cls.__name__}' deriving from 'ShapeCastable' must override "
                             f"the '__call__' method")
         if cls.from_bits is ShapeCastable.from_bits:
-            warnings.warn(f"Class '{cls.__name__}' deriving from 'ShapeCastable' does not override "
-                          f"the 'from_bits' method, which will be required in Amaranth 0.6",
-                          DeprecationWarning, stacklevel=2)
+            raise TypeError(f"Class '{cls.__name__}' deriving from 'ShapeCastable' must override "
+                            f"the 'from_bits' method")
 
     # The signatures and definitions of these methods are weird because they are present here for
     # documentation (and error checking above) purpose only and should not affect control flow.
@@ -321,8 +320,10 @@ def const(self, *args, **kwargs):
         """
         return super().const(*args, **kwargs) # :nocov:
 
-    def from_bits(self, raw):
-        """Lift a bit pattern to a higher-level representation.
+    def from_bits(self, *args, **kwargs):
+        """from_bits(raw)
+
+        Lift a bit pattern to a higher-level representation.
 
         This method is called by the Amaranth language to lift :py:`raw`, which is an :class:`int`,
         to a higher-level representation, which may be any object accepted by :meth:`const`.
@@ -353,7 +354,7 @@ def from_bits(self, raw):
             either directly or as a cause of another exception. While not constrained here,
             usually the exception class will be :exc:`ValueError`.
         """
-        return raw
+        return super().from_bits(*args, **kwargs) # :nocov:
 
     def __call__(self, *args, **kwargs):
         """__call__(obj)

amaranth/lib/data.py

@@ -922,8 +922,8 @@ class Const(ValueCastable):
     Slicing a constant or accessing its attributes returns a part of the underlying value
     corresponding to the field with that index or name. If the shape of the field is
     a :class:`Layout`, the returned value is a :class:`Const`; if it is a different
-    :ref:`shape-like <lang-shapelike>` object implementing :meth:`~.ShapeCastable.from_bits`,
-    it will be the result of calling that method; otherwise, it is an :class:`int`.
+    :ref:`shape-like <lang-shapelike>` object, it will be the result of calling
+    :meth:`~.ShapeCastable.from_bits`; otherwise, it is an :class:`int`.
 
     Slicing a constant whose layout is an :class:`ArrayLayout` can be done with an index that is
     an Amaranth value rather than a constant integer. The returned element is chosen dynamically
@@ -990,8 +990,8 @@ def __getitem__(self, key):
         """Slice the underlying value.
 
         A field corresponding to :py:`key` is looked up in the layout. If the field's shape is
-        a shape-castable object that has a :meth:`~.ShapeCastable.from_bits` method, returns
-        the result of calling that method. Otherwise, returns an :class:`int`.
+        a shape-castable object, returns the result of calling :meth:`~.ShapeCastable.from_bits`.
+        Otherwise, returns an :class:`int`.
 
         Arguments
         ---------

docs/changes.rst

@@ -28,6 +28,7 @@ Language changes
 
 .. currentmodule:: amaranth.hdl
 
+* Changed: overriding :meth:`ValueCastable.from_bits` is now mandatory. (`RFC 51`_)
 * Removed: (deprecated in 0.4) :class:`Record`.
 * Removed: (deprecated in 0.5) public submodules of :mod:`amaranth.hdl`.
 * Removed: (deprecated in 0.5) :meth:`Value.implies`.

tests/test_hdl_ast.py

@@ -211,25 +211,6 @@ def test_abstract(self):
                 r"^Can't instantiate abstract class ShapeCastable$"):
             ShapeCastable()
 
-    def test_no_from_bits(self):
-        with self.assertWarnsRegex(DeprecationWarning,
-                r"^Class 'MockShapeCastableNoFromBits' deriving from 'ShapeCastable' does "
-                r"not override the 'from_bits' method, which will be required in Amaranth 0.6$"):
-            class MockShapeCastableNoFromBits(ShapeCastable):
-                def __init__(self, dest):
-                    self.dest = dest
-
-                def as_shape(self):
-                    return self.dest
-
-                def __call__(self, value):
-                    return value
-
-                def const(self, init):
-                    return Const(init, self.dest)
-
-        self.assertEqual(MockShapeCastableNoFromBits(unsigned(2)).from_bits(123), 123)
-
 
 class ShapeLikeTestCase(FHDLTestCase):
     def test_construct(self):