lib.wiring: preserve insertion order in SignatureMembers.__iter__.

amaranth/lib/wiring.py

@@ -163,7 +163,7 @@ class SignatureMembers(Mapping):
 
     def __eq__(self, other):
         return (isinstance(other, (SignatureMembers, FlippedSignatureMembers)) and
-                list(self.flatten()) == list(other.flatten()))
+                list(sorted(self.flatten())) == list(sorted(other.flatten())))
 
     def __contains__(self, name):
         return name in self._dict
@@ -189,7 +189,7 @@ class SignatureMembers(Mapping):
         raise SignatureError("Members cannot be removed from a signature")
 
     def __iter__(self):
-        return iter(sorted(self._dict))
+        return iter(self._dict)
 
     def __len__(self):
         return len(self._dict)
@@ -647,7 +647,7 @@ def connect(m, *args, **kwargs):
         signatures[handle] = obj.signature
 
     # Collate signatures and build connections.
-    flattens = {handle: signature.members.flatten()
+    flattens = {handle: iter(sorted(signature.members.flatten()))
                 for handle, signature in signatures.items()}
     connections = []
     # Each iteration of the outer loop is intended to connect several (usually a pair) members

tests/test_lib_wiring.py

@@ -200,11 +200,11 @@ class SignatureMembersTestCase(unittest.TestCase):
         self.assertEqual(list(iter(members)), ["a"])
         self.assertEqual(len(members), 1)
 
-    def test_iter_sorted(self):
+    def test_iter_insertion_order(self):
         self.assertEqual(list(iter(SignatureMembers({"a": In(1), "b": Out(1)}))),
                          ["a", "b"])
         self.assertEqual(list(iter(SignatureMembers({"b": In(1), "a": Out(1)}))),
-                         ["a", "b"])
+                         ["b", "a"])
 
     def test_flatten(self):
         sig = Signature({
@@ -915,6 +915,27 @@ class ConnectTestCase(unittest.TestCase):
             '(eq (sig q__a) (sig p__a))'
         ])
 
+    def test_unordered(self):
+        m = Module()
+        connect(m,
+                p=NS(signature=Signature({"a": Out(1),
+                                          "b": Out(Signature({"f": Out(1), "g": Out(1)}))}),
+                     a=Signal(name="p__a"),
+                     b=NS(signature=Signature({"f": Out(1), "g": Out(1)}),
+                          f=Signal(name="p__b__f"),
+                          g=Signal(name="p__b__g"))),
+                q=NS(signature=Signature({"b": In(Signature({"g": Out(1), "f": Out(1)})),
+                                          "a": In(1)}),
+                     b=NS(signature=Signature({"g": Out(1), "f": Out(1)}).flip(),
+                          g=Signal(name="q__b__g"),
+                          f=Signal(name="q__b__f")),
+                     a=Signal(name="q__a")))
+        self.assertEqual([repr(stmt) for stmt in m._statements], [
+            '(eq (sig q__a) (sig p__a))',
+            '(eq (sig q__b__f) (sig p__b__f))',
+            '(eq (sig q__b__g) (sig p__b__g))',
+        ])
+
     def test_dimension(self):
         sig = Signature({"a": Out(1).array(2)})