Merge branch 'amaranth-lang:main' into main

Author: slagernate

.env.toolchain

@@ -0,0 +1,7 @@
+AMARANTH_USE_YOSYS=system
+YOSYS=yowasp-yosys
+SBY=yowasp-sby
+SMTBMC=yowasp-yosys-smtbmc
+# examples
+NEXTPNR_ICE40=yowasp-nextpnr-ice40
+ICEPACK=yowasp-icepack

.github/workflows/main.yaml

@@ -15,23 +15,18 @@ jobs:
         - '3.9'
         - '3.10'
         - '3.11'
+        - '3.12'
         - 'pypy-3.8'
         - 'pypy-3.9'
+        - 'pypy-3.10'
         allow-failure:
         - false
         include:
-        - python-version: '3.12-dev'
+        - python-version: '3.13-dev'
           allow-failure: true
     continue-on-error: '${{ matrix.allow-failure }}'
     name: 'test (${{ matrix.python-version }})'
     steps:
-    - name: Preserve Wasm cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ~/.cache/wasmtime
-          ~/.cache/YoWASP
-        key: ${{ runner.os }}-wasm
     - name: Check out source code
       uses: actions/checkout@v3
       with:
@@ -46,15 +41,16 @@ jobs:
         sudo add-apt-repository 'deb http://ppa.launchpad.net/sri-csl/formal-methods/ubuntu bionic main'
         sudo apt-get update
         sudo apt-get install yices2
-        pip install codecov yowasp-yosys
+        pip install codecov
         pdm install --dev
+    - name: Cache YoWASP build products
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/YoWASP
+        key: YoWASP-${{ runner.os }}-${{ hashFiles('./.venv/**/*.wasm') }}
+        restore-keys: |
+          YoWASP-${{ runner.os }}-
     - name: Run tests
-      env:
-        YOSYS: yowasp-yosys
-        NEXTPNR_ICE40: yowasp-nextpnr-ice40
-        ICEPACK: yowasp-icepack
-        SBY: yowasp-sby
-        SMTBMC: yowasp-yosys-smtbmc
       run: |
         pdm run test
     - name: Submit code coverage
@@ -87,14 +83,14 @@ jobs:
           name: docs
           path: docs/_build
 
-  required: # group all required workflows into one for the required status check
+  required: # group all required workflows into one to avoid reconfiguring this in Actions settings
     needs:
       - test
       - document
+    if: always() && !contains(needs.*.result, 'cancelled')
     runs-on: ubuntu-latest
     steps:
-      - run: |
-          true
+      - run: ${{ contains(needs.*.result, 'failure') && 'false' || 'true' }}
 
   publish-docs:
     needs: document

amaranth/build/plat.py

@@ -303,7 +303,7 @@ def iter_clock_constraints(self):
                 continue
             yield net_signal, port_signal, frequency
 
-    def toolchain_prepare(self, fragment, name, **kwargs):
+    def toolchain_prepare(self, fragment, name, *, emit_src=True, **kwargs):
         # Restrict the name of the design to a strict alphanumeric character set. Platforms will
         # interpolate the name of the design in many different contexts: filesystem paths, Python
         # scripts, Tcl scripts, ad-hoc constraint files, and so on. It is not practical to add
@@ -319,7 +319,7 @@ def toolchain_prepare(self, fragment, name, **kwargs):
         # and to incorporate the Amaranth version into generated code.
         autogenerated = "Automatically generated by Amaranth {}. Do not edit.".format(__version__)
 
-        rtlil_text, self._name_map = rtlil.convert_fragment(fragment, name=name)
+        rtlil_text, self._name_map = rtlil.convert_fragment(fragment, name=name, emit_src=emit_src)
 
         # Retrieve an override specified in either the environment or as a kwarg.
         # expected_type parameter is used to assert the type of kwargs, passing `None` will disable

amaranth/build/res.py

@@ -137,17 +137,22 @@ def resolve(resource, dir, xdr, name, attrs):
                 # ignore it as well.
                 if isinstance(phys, Pins):
                     phys_names = phys.names
-                    port = wiring.Signature({"io": wiring.In(len(phys))}).create(path=(name,))
+                    port = Record([("io", len(phys))], name=name)
+                    port.signature = wiring.Signature({"io": wiring.In(len(phys))})
                 if isinstance(phys, DiffPairs):
                     phys_names = []
-                    members = {}
+                    rec_members = []
+                    sig_members = {}
                     if not self.should_skip_port_component(None, attrs, "p"):
                         phys_names += phys.p.names
-                        members["p"] = wiring.In(len(phys))
+                        rec_members.append(("p", len(phys)))
+                        sig_members["p"] = wiring.In(len(phys))
                     if not self.should_skip_port_component(None, attrs, "n"):
                         phys_names += phys.n.names
-                        members["n"] = wiring.In(len(phys))
-                    port = wiring.Signature(members).create(path=(name,))
+                        rec_members.append(("n", len(phys)))
+                        sig_members["n"] = wiring.In(len(phys))
+                    port = Record(rec_members, name=name)
+                    port.signature = wiring.Signature(sig_members)
                 if dir == "-":
                     pin = None
                 else:

amaranth/hdl/ast.py

@@ -156,6 +156,25 @@ def signed(width):
     return Shape(width, signed=True)
 
 
+def _overridable_by_reflected(method_name):
+    """Allow overriding the decorated method.
+
+    Allows :class:`ValueCastable` to override the decorated method by implementing
+    a reflected method named ``method_name``. Intended for operators, but
+    also usable for other methods that have a reflected counterpart.
+    """
+    def decorator(f):
+        @functools.wraps(f)
+        def wrapper(self, other):
+            if isinstance(other, ValueCastable) and hasattr(other, method_name):
+                res = getattr(other, method_name)(self)
+                if res is not NotImplemented:
+                    return res
+            return f(self, other)
+        return wrapper
+    return decorator
+
+
 class Value(metaclass=ABCMeta):
     @staticmethod
     def cast(obj):
@@ -195,26 +214,31 @@ def __invert__(self):
     def __neg__(self):
         return Operator("-", [self])
 
+    @_overridable_by_reflected("__radd__")
     def __add__(self, other):
-        return Operator("+", [self, other])
+        return Operator("+", [self, other], src_loc_at=1)
     def __radd__(self, other):
         return Operator("+", [other, self])
+    @_overridable_by_reflected("__rsub__")
     def __sub__(self, other):
-        return Operator("-", [self, other])
+        return Operator("-", [self, other], src_loc_at=1)
     def __rsub__(self, other):
         return Operator("-", [other, self])
 
+    @_overridable_by_reflected("__rmul__")
     def __mul__(self, other):
-        return Operator("*", [self, other])
+        return Operator("*", [self, other], src_loc_at=1)
     def __rmul__(self, other):
         return Operator("*", [other, self])
 
+    @_overridable_by_reflected("__rmod__")
     def __mod__(self, other):
-        return Operator("%", [self, other])
+        return Operator("%", [self, other], src_loc_at=1)
     def __rmod__(self, other):
         return Operator("%", [other, self])
+    @_overridable_by_reflected("__rfloordiv__")
     def __floordiv__(self, other):
-        return Operator("//", [self, other])
+        return Operator("//", [self, other], src_loc_at=1)
     def __rfloordiv__(self, other):
         return Operator("//", [other, self])
 
@@ -224,46 +248,57 @@ def __check_shamt(self):
             # by a signed value to make sure the shift amount can always be interpreted as
             # an unsigned value.
             raise TypeError("Shift amount must be unsigned")
+    @_overridable_by_reflected("__rlshift__")
     def __lshift__(self, other):
         other = Value.cast(other)
         other.__check_shamt()
-        return Operator("<<", [self, other])
+        return Operator("<<", [self, other], src_loc_at=1)
     def __rlshift__(self, other):
         self.__check_shamt()
         return Operator("<<", [other, self])
+    @_overridable_by_reflected("__rrshift__")
     def __rshift__(self, other):
         other = Value.cast(other)
         other.__check_shamt()
-        return Operator(">>", [self, other])
+        return Operator(">>", [self, other], src_loc_at=1)
     def __rrshift__(self, other):
         self.__check_shamt()
         return Operator(">>", [other, self])
 
+    @_overridable_by_reflected("__rand__")
     def __and__(self, other):
-        return Operator("&", [self, other])
+        return Operator("&", [self, other], src_loc_at=1)
     def __rand__(self, other):
         return Operator("&", [other, self])
+    @_overridable_by_reflected("__rxor__")
     def __xor__(self, other):
-        return Operator("^", [self, other])
+        return Operator("^", [self, other], src_loc_at=1)
     def __rxor__(self, other):
         return Operator("^", [other, self])
+    @_overridable_by_reflected("__ror__")
     def __or__(self, other):
-        return Operator("|", [self, other])
+        return Operator("|", [self, other], src_loc_at=1)
     def __ror__(self, other):
         return Operator("|", [other, self])
 
+    @_overridable_by_reflected("__eq__")
     def __eq__(self, other):
-        return Operator("==", [self, other])
+        return Operator("==", [self, other], src_loc_at=1)
+    @_overridable_by_reflected("__ne__")
     def __ne__(self, other):
-        return Operator("!=", [self, other])
+        return Operator("!=", [self, other], src_loc_at=1)
+    @_overridable_by_reflected("__gt__")
     def __lt__(self, other):
-        return Operator("<", [self, other])
+        return Operator("<", [self, other], src_loc_at=1)
+    @_overridable_by_reflected("__ge__")
     def __le__(self, other):
-        return Operator("<=", [self, other])
+        return Operator("<=", [self, other], src_loc_at=1)
+    @_overridable_by_reflected("__lt__")
     def __gt__(self, other):
-        return Operator(">", [self, other])
+        return Operator(">", [self, other], src_loc_at=1)
+    @_overridable_by_reflected("__le__")
     def __ge__(self, other):
-        return Operator(">=", [self, other])
+        return Operator(">=", [self, other], src_loc_at=1)
 
     def __abs__(self):
         if self.shape().signed:

amaranth/hdl/mem.py

@@ -187,7 +187,8 @@ def elaborate(self, platform):
                                 parts.append(Mux(cond, write_port.data[bits], data[bits]))
                             data = Cat(parts)
                         else:
-                            data = Mux(write_port.en, write_port.data, data)
+                            cond = write_port.en & (port.addr == write_port.addr)
+                            data = Mux(cond, write_port.data, data)
                 f.add_statements(
                     Switch(port.en, {
                         1: port.data.eq(data)

amaranth/lib/data.py

@@ -229,7 +229,7 @@ def const(self, init):
             mask = ((1 << cast_field_shape.width) - 1) << field.offset
             int_value &= ~mask
             int_value |= (key_value.value << field.offset) & mask
-        return Const(int_value, self.as_shape())
+        return View(self, Const(int_value, self.as_shape()))
 
 
 class StructLayout(Layout):

amaranth/lib/enum.py

@@ -83,16 +83,23 @@ def __new__(metacls, name, bases, namespace, shape=None, **kwargs):
                         category=SyntaxWarning,
                         stacklevel=2)
         # Actually instantiate the enumeration class.
-        cls = py_enum.EnumMeta.__new__(metacls, name, bases, namespace, **kwargs)
         if shape is not None:
+            cls = py_enum.EnumMeta.__new__(metacls, name, bases, namespace, **kwargs)
             # Shape is provided explicitly. Set the `_amaranth_shape_` attribute, and check that
             # the values of every member can be cast to the provided shape without truncation.
             cls._amaranth_shape_ = shape
         else:
             # Shape is not provided explicitly. Behave the same as a standard enumeration;
             # the lack of `_amaranth_shape_` attribute is used to emit a warning when such
             # an enumeration is used in a concatenation.
-            pass
+            bases = tuple(
+                py_enum.Enum if base is Enum else
+                py_enum.IntEnum if base is IntEnum else
+                py_enum.Flag if base is Flag else
+                py_enum.IntFlag if base is IntFlag else base
+                for base in bases
+            )
+            cls = py_enum.EnumMeta.__new__(py_enum.EnumMeta, name, bases, namespace, **kwargs)
         return cls
 
     def as_shape(cls):
@@ -118,7 +125,7 @@ def as_shape(cls):
             # replacement for `enum.Enum`.
             return Shape._cast_plain_enum(cls)
 
-    def __call__(cls, value):
+    def __call__(cls, value, *args, **kwargs):
         # :class:`py_enum.Enum` uses ``__call__()`` for type casting: ``E(x)`` returns
         # the enumeration member whose value equals ``x``. In this case, ``x`` must be a concrete
         # value.
@@ -130,7 +137,7 @@ def __call__(cls, value):
         # comparisons with enum members of the wrong type.
         if isinstance(value, Value):
             return value
-        return super().__call__(value)
+        return super().__call__(value, *args, **kwargs)
 
     def const(cls, init):
         # Same considerations apply as above.
@@ -144,21 +151,28 @@ def const(cls, init):
         return Const(member.value, cls.as_shape())
 
 
-class Enum(py_enum.Enum, metaclass=EnumMeta):
+class Enum(py_enum.Enum):
     """Subclass of the standard :class:`enum.Enum` that has :class:`EnumMeta` as
     its metaclass."""
 
 
-class IntEnum(py_enum.IntEnum, metaclass=EnumMeta):
+class IntEnum(py_enum.IntEnum):
     """Subclass of the standard :class:`enum.IntEnum` that has :class:`EnumMeta` as
     its metaclass."""
 
 
-class Flag(py_enum.Flag, metaclass=EnumMeta):
+class Flag(py_enum.Flag):
     """Subclass of the standard :class:`enum.Flag` that has :class:`EnumMeta` as
     its metaclass."""
 
 
-class IntFlag(py_enum.IntFlag, metaclass=EnumMeta):
+class IntFlag(py_enum.IntFlag):
     """Subclass of the standard :class:`enum.IntFlag` that has :class:`EnumMeta` as
     its metaclass."""
+
+# Fix up the metaclass after the fact: the metaclass __new__ requires these classes
+# to already be present, and also would not install itself on them due to lack of shape.
+Enum.__class__ = EnumMeta
+IntEnum.__class__ = EnumMeta
+Flag.__class__ = EnumMeta
+IntFlag.__class__ = EnumMeta