Fix use of enums in concatenation expressions. #230

Author: amykyta3

.github/workflows/build.yml

@@ -261,6 +261,7 @@ jobs:
       - build_sdist
 
     runs-on: ubuntu-latest
+    environment: release
 
     # Only publish when a GitHub Release is created.
     if: github.event_name == 'release'
@@ -271,6 +272,3 @@ jobs:
           path: dist
 
       - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.pypi_password }}

src/systemrdl/ast/sequence.py

@@ -15,20 +15,11 @@ def __init__(self, env: 'RDLEnvironment', src_ref: 'OptionalSourceRef', elements
         self.elements = elements
         self.type = None # type: Union[Type[int], Type[str]]
 
-    def predict_type(self):
-        # type: () -> Union[Type[int], Type[str]]
-
-        # Get type of first element
+    def predict_type(self) -> Union[Type[int], Type[str]]:
         element_iter = iter(self.elements)
-        element_type = next(element_iter).predict_type()
 
-        # All remaining elements shall match
-        for element in element_iter:
-            if element_type != element.predict_type():
-                self.msg.fatal(
-                    "Elements of a concatenation shall be the same type",
-                    self.src_ref
-                )
+        # first element defines the type of the concatenation
+        element_type = next(element_iter).predict_type()
         if is_castable(element_type, int):
             self.type = int
         elif is_castable(element_type, str):
@@ -38,6 +29,14 @@ def predict_type(self):
                 "Concatenation operator can only be used for integral or string types",
                 self.src_ref
             )
+
+        # All remaining elements shall be castable to the concatenation type
+        for element in element_iter:
+            if not is_castable(element.predict_type(), self.type):
+                self.msg.fatal(
+                    "Elements of a concatenation shall be the same type",
+                    self.src_ref
+                )
         return self.type
 
     def get_min_eval_width(self) -> int:

test/rdl_src/enums_in_expressions.rdl

@@ -0,0 +1,41 @@
+property int_prop {
+    type = longint;
+    component = all;
+};
+
+addrmap enum_expr_test {
+    enum my_enum1 {
+        zero;
+        one;
+        two;
+        three;
+    };
+
+    enum my_enum2 {
+        ten = 10;
+        eleven = 11;
+        twelve = 12;
+        thirteen = 13;
+    };
+
+    reg myreg {
+        field {} f;
+    };
+
+    // convenience macro that instantiates the reg, and assigns the UDP with an expression
+    `define EXPR(name, expr) myreg name; name->int_prop = expr
+
+    `EXPR(concat1, {my_enum2::twelve, 8'h10});
+    `EXPR(concat2, {8'h22, my_enum2::thirteen, 8'h10});
+    `EXPR(concat3, {8'h22, (8)'(my_enum2::thirteen), 8'h10});
+    `EXPR(repl, {3{my_enum1::three}});
+    `EXPR(add, my_enum1::three + 5);
+    `EXPR(sub, my_enum1::three - 1);
+    `EXPR(mul, my_enum1::three * 2);
+    `EXPR(div, my_enum2::twelve / 2);
+    `EXPR(mod, my_enum2::twelve % 5);
+    `EXPR(and, my_enum2::twelve & 9);
+    `EXPR(or, my_enum2::twelve | 9);
+    `EXPR(xor, my_enum2::twelve ^ 9);
+    `EXPR(inv, ~my_enum2::twelve);
+};

test/test_enums.py

@@ -81,3 +81,26 @@ def test_enums_pickleable(self):
                 self.assertEqual(m.rdl_desc, m2.rdl_desc)
             self.assertIs(type(e).__class__, type(e2).__class__)
             self.assertIs(type(e).__module__, type(e2).__module__)
+
+    def test_enums_in_expressions(self):
+        root = self.compile(
+            ["rdl_src/enums_in_expressions.rdl"],
+            "enum_expr_test"
+        )
+        def check_result(name: str, value: int):
+            reg = root.top.get_child_by_name(name)
+            self.assertEqual(reg.get_property("int_prop"), value)
+
+        check_result("concat1", 0xC10)
+        check_result("concat2", 0x22000000000000000D10)
+        check_result("concat3", 0x220D10)
+        check_result("repl", 0x000000000000000300000000000000030000000000000003)
+        check_result("add", 8)
+        check_result("sub", 2)
+        check_result("mul", 6)
+        check_result("div", 6)
+        check_result("mod", 2)
+        check_result("and", 8)
+        check_result("or", 13)
+        check_result("xor", 5)
+        check_result("inv", 0xFFFFFFFF_FFFFFFF3)