csr.reg: check the signature of fields instantiated by Field.create().

Author: jfng

amaranth_soc/csr/reg.py

@@ -170,8 +170,16 @@ class Field:
         Positional arguments passed to ``field_cls.__init__``.
     **kwargs : :class:`dict`
         Keyword arguments passed to ``field_cls.__init__``.
+
+    Raises
+    ------
+    :exc:`TypeError`
+        If ``field_cls`` is not a subclass of :class:`wiring.Component`.
     """
     def __init__(self, field_cls, *args, **kwargs):
+        if not issubclass(field_cls, wiring.Component):
+            raise TypeError(f"{field_cls.__qualname__} must be a subclass of wiring.Component")
+
         self._field_cls = field_cls
         self._args      = args
         self._kwargs    = kwargs
@@ -183,8 +191,22 @@ def create(self):
         -------
         :class:`object`
             The instance returned by ``field_cls(*args, **kwargs)``.
+
+        Raises
+        ------
+        :exc:`TypeError`
+            If the instance returned by ``field_cls(*args, **kwargs)`` doesn't have a signature
+            with a member named "port" that is a :class:`FieldPort.Signature` with a
+            :attr:`wiring.In` direction.
         """
-        return self._field_cls(*self._args, **self._kwargs)
+        field = self._field_cls(*self._args, **self._kwargs)
+        if not ("port" in field.signature.members
+                and field.signature.members["port"].flow is In
+                and field.signature.members["port"].is_signature
+                and isinstance(field.signature.members["port"].signature, FieldPort.Signature)):
+            raise TypeError(f"{self._field_cls.__qualname__} instance signature must have a "
+                            f"csr.FieldPort.Signature member named 'port' and oriented as In")
+        return field
 
 
 class FieldMap(Mapping):

tests/test_csr_reg.py

@@ -120,10 +120,20 @@ def test_wrong_signature(self):
 
 
 class FieldTestCase(unittest.TestCase):
+    def test_wrong_class(self):
+        class Foo:
+            pass
+        with self.assertRaisesRegex(TypeError,
+                r"Foo must be a subclass of wiring.Component"):
+            Field(Foo)
+
     def test_create(self):
         class MockField(wiring.Component):
             def __init__(self, shape, *, reset):
-                super().__init__({"port": Out(FieldPort.Signature(shape, "rw"))})
+                super().__init__({
+                    "port": In(FieldPort.Signature(shape, "rw")),
+                    "data": Out(shape)
+                })
                 self.reset = reset
 
             def elaborate(self, platform):
@@ -135,7 +145,7 @@ def elaborate(self, platform):
 
     def test_create_multiple(self):
         class MockField(wiring.Component):
-            port: Out(FieldPort.Signature(unsigned(8), "rw"))
+            port: In(FieldPort.Signature(unsigned(8), "rw"))
 
             def elaborate(self, platform):
                 return Module()
@@ -144,6 +154,58 @@ def elaborate(self, platform):
         field_2 = Field(MockField).create()
         self.assertIsNot(field_1, field_2)
 
+    def test_wrong_port_name(self):
+        class MockField(wiring.Component):
+            foo: In(FieldPort.Signature(unsigned(1), access="rw"))
+
+            def elaborate(self, platform):
+                return Module()
+
+        field = Field(MockField)
+        with self.assertRaisesRegex(TypeError,
+                r"MockField instance signature must have a csr\.FieldPort\.Signature member named "
+                r"'port' and oriented as In"):
+            field.create()
+
+    def test_wrong_port_direction(self):
+        class MockField(wiring.Component):
+            port: Out(FieldPort.Signature(unsigned(1), access="rw"))
+
+            def elaborate(self, platform):
+                return Module()
+
+        field = Field(MockField)
+        with self.assertRaisesRegex(TypeError,
+                r"MockField instance signature must have a csr\.FieldPort\.Signature member named "
+                r"'port' and oriented as In"):
+            field.create()
+
+    def test_wrong_port_type_port(self):
+        class MockField(wiring.Component):
+            port: In(unsigned(1))
+
+            def elaborate(self, platform):
+                return Module()
+
+        field = Field(MockField)
+        with self.assertRaisesRegex(TypeError,
+                r"MockField instance signature must have a csr\.FieldPort\.Signature member named "
+                r"'port' and oriented as In"):
+            field.create()
+
+    def test_wrong_port_type_signature(self):
+        class MockField(wiring.Component):
+            port: In(wiring.Signature({"foo": Out(unsigned(1))}))
+
+            def elaborate(self, platform):
+                return Module()
+
+        field = Field(MockField)
+        with self.assertRaisesRegex(TypeError,
+                r"MockField instance signature must have a csr\.FieldPort\.Signature member named "
+                r"'port' and oriented as In"):
+            field.create()
+
 
 class FieldMapTestCase(unittest.TestCase):
     def test_simple(self):