Rename ArrayPlaceholder class to ArrayedType. Added some more UDP testcases

amykyta3 · amykyta3 · commit 7b483746ee4f · 2023-10-21T21:02:23.000-07:00
diff --git a/systemrdl/ast/cast.py b/systemrdl/ast/cast.py
@@ -142,7 +142,7 @@ def is_castable(src: Any, dst: Any) -> bool:
     if ((src in [int, bool]) or rdltypes.is_user_enum(src)) and (dst in [int, bool]):
         # Pure numeric or enum can be cast to a numeric
         return True
-    elif isinstance(src, rdltypes.ArrayPlaceholder) and isinstance(dst, rdltypes.ArrayPlaceholder):
+    elif isinstance(src, rdltypes.ArrayedType) and isinstance(dst, rdltypes.ArrayedType):
         # Check that array element types also match
         if src.element_type is None:
             # indeterminate array type. Is castable
diff --git a/systemrdl/ast/literals.py b/systemrdl/ast/literals.py
@@ -120,25 +120,25 @@ def __init__(self, env: 'RDLEnvironment', src_ref: 'OptionalSourceRef', elements
         super().__init__(env, src_ref)
         self.elements = elements
 
-    def predict_type(self) -> rdltypes.ArrayPlaceholder:
+    def predict_type(self) -> rdltypes.ArrayedType:
 
         if not self.elements:
             # Empty array. Element type is indeterminate
-            return rdltypes.ArrayPlaceholder(None)
+            return rdltypes.ArrayedType(None)
 
         # Get type of first element
         element_iter = iter(self.elements)
         uniform_type = next(element_iter).predict_type()
 
         # RDL does not allow directly nested arrays
-        assert not isinstance(uniform_type, rdltypes.ArrayPlaceholder)
+        assert not isinstance(uniform_type, rdltypes.ArrayedType)
 
         # All elements of the array shall have a uniform type
         for element in element_iter:
             this_type = element.predict_type()
 
             # RDL does not allow directly nested arrays
-            assert not isinstance(this_type, rdltypes.ArrayPlaceholder)
+            assert not isinstance(this_type, rdltypes.ArrayedType)
 
             # First check if it is a direct match
             if uniform_type == this_type:
@@ -176,7 +176,7 @@ def predict_type(self) -> rdltypes.ArrayPlaceholder:
                 self.src_ref
             )
 
-        return rdltypes.ArrayPlaceholder(uniform_type)
+        return rdltypes.ArrayedType(uniform_type)
 
     def get_value(self, eval_width: Optional[int]=None) -> List[Any]:
         result = []
diff --git a/systemrdl/ast/references.py b/systemrdl/ast/references.py
@@ -54,12 +54,12 @@ def predict_type(self) -> 'PreElabRDLType':
             )
 
         array_type = self.array.predict_type()
-        if not isinstance(array_type, rdltypes.ArrayPlaceholder):
+        if not isinstance(array_type, rdltypes.ArrayedType):
             self.msg.fatal(
                 "Cannot index non-array type",
                 self.array.src_ref
             )
-        assert isinstance(array_type, rdltypes.ArrayPlaceholder)
+        assert isinstance(array_type, rdltypes.ArrayedType)
 
         return array_type.element_type
 
diff --git a/systemrdl/core/ComponentVisitor.py b/systemrdl/core/ComponentVisitor.py
@@ -512,10 +512,10 @@ def visitParam_def_elem(self, ctx: SystemRDLParser.Param_def_elemContext) -> Par
         param_data_type = self.datatype_from_token(data_type_token)
         if ctx.array_type_suffix() is None:
             # Non-array type
-            param_type = param_data_type # type: Union[Type[Union[int, str, bool, rdltypes.BuiltinEnum, rdltypes.UserEnum, rdltypes.UserStruct, rdltypes.references.RefType, comp.Component]], rdltypes.ArrayPlaceholder]
+            param_type = param_data_type # type: Union[Type[Union[int, str, bool, rdltypes.BuiltinEnum, rdltypes.UserEnum, rdltypes.UserStruct, rdltypes.references.RefType, comp.Component]], rdltypes.ArrayedType]
         else:
             # Array-like type
-            param_type = rdltypes.ArrayPlaceholder(param_data_type)
+            param_type = rdltypes.ArrayedType(param_data_type)
 
         # Get parameter name
         param_name = get_ID_text(ctx.ID())
diff --git a/systemrdl/core/StructVisitor.py b/systemrdl/core/StructVisitor.py
@@ -81,7 +81,7 @@ def visitStruct_elem(self, ctx: SystemRDLParser.Struct_elemContext):
         member_type = self.visit(ctx.struct_type())
 
         if ctx.array_type_suffix() is not None:
-            member_type = rdltypes.ArrayPlaceholder(member_type)
+            member_type = rdltypes.ArrayedType(member_type)
 
         return member_type, member_name, member_src_ref
 
diff --git a/systemrdl/core/UDPVisitor.py b/systemrdl/core/UDPVisitor.py
@@ -15,7 +15,7 @@
 from .. import rdltypes
 
 if TYPE_CHECKING:
-    from typing import Optional, Union, Any, Set, Tuple
+    from typing import Optional, Union, Any, Set
     from ..compiler import RDLCompiler
 
 class UDPVisitor(BaseVisitor):
@@ -124,7 +124,7 @@ def visitUdp_type(self, ctx: SystemRDLParser.Udp_typeContext) -> None:
         is_array = ctx.array_type_suffix() is not None
         if is_array:
             # arrayify
-            valid_type = rdltypes.ArrayPlaceholder(valid_type) # type: ignore
+            valid_type = rdltypes.ArrayedType(valid_type) # type: ignore
 
         self._valid_type = valid_type
 
diff --git a/systemrdl/properties/builtin.py b/systemrdl/properties/builtin.py
@@ -221,14 +221,14 @@ class Prop_hdl_path_gate(PropertyRule):
 
 class Prop_hdl_path_gate_slice(PropertyRule):
     bindable_to = {comp.Field, comp.Mem}
-    valid_types = (rdltypes.ArrayPlaceholder(str),)
+    valid_types = (rdltypes.ArrayedType(str),)
     default = None
     dyn_assign_allowed = True
 
 
 class Prop_hdl_path_slice(PropertyRule):
     bindable_to = {comp.Field, comp.Mem}
-    valid_types = (rdltypes.ArrayPlaceholder(str),)
+    valid_types = (rdltypes.ArrayedType(str),)
     default = None
     dyn_assign_allowed = True
 
diff --git a/systemrdl/properties/user_defined.py b/systemrdl/properties/user_defined.py
@@ -38,7 +38,7 @@ def constr_componentwidth(self) -> bool:
 
     @property
     def valid_types(self) -> Tuple[Any, ...]: # type: ignore
-        if isinstance(self.valid_type, rdltypes.ArrayPlaceholder):
+        if isinstance(self.valid_type, rdltypes.ArrayedType):
             return (self.valid_type,)
         if issubclass(self.valid_type, rdltypes.references.RefType):
             return self.valid_type.expanded
diff --git a/systemrdl/py.typed b/systemrdl/py.typed
diff --git a/systemrdl/rdltypes/__init__.py b/systemrdl/rdltypes/__init__.py
@@ -8,9 +8,9 @@
 
 from .user_struct import UserStruct, is_user_struct
 
-from .array import ArrayPlaceholder
+from .array import ArrayedType
 
-from .references import ComponentRef, PropertyReference
+from .references import ComponentRef, PropertyReference, RefType
 
 if TYPE_CHECKING:
     from .typing import PreElabRDLType
@@ -32,7 +32,7 @@ def get_rdltype(value: Any) -> 'PreElabRDLType':
     elif isinstance(value, BuiltinEnum):
         return type(value)
     elif isinstance(value, list):
-        # Create ArrayPlaceholder representation
+        # Create ArrayedType representation
         # Determine element type and make sure it is uniform
         array_el_type = None # type: Optional[PreElabRDLType]
         for el in value:
@@ -43,7 +43,7 @@ def get_rdltype(value: Any) -> 'PreElabRDLType':
             if (array_el_type is not None) and (el_type != array_el_type):
                 return None
             array_el_type = el_type
-        return ArrayPlaceholder(array_el_type)
+        return ArrayedType(array_el_type)
     else:
         return None
 
diff --git a/systemrdl/rdltypes/array.py b/systemrdl/rdltypes/array.py
@@ -3,7 +3,7 @@
 if TYPE_CHECKING:
     from .typing import PreElabRDLType
 
-class ArrayPlaceholder():
+class ArrayedType():
     """
     Placeholder class to describe array types
 
@@ -15,7 +15,7 @@ def __init__(self, element_type: 'PreElabRDLType'):
         self.element_type = element_type
 
     def __eq__(self, other: Any) -> bool:
-        if isinstance(other, ArrayPlaceholder):
+        if isinstance(other, ArrayedType):
             return self.element_type == other.element_type
         else:
             return NotImplemented
diff --git a/systemrdl/rdltypes/typing.py b/systemrdl/rdltypes/typing.py
@@ -6,7 +6,7 @@
     from .user_enum import UserEnum
     from .references import PropertyReference, RefType
     from .user_struct import UserStruct
-    from .array import ArrayPlaceholder
+    from .array import ArrayedType
     from ..node import Node
     from .. import component as comp
 
@@ -29,7 +29,7 @@
 ]
 
 if sys.version_info >= (3,5,4):
-    PreElabRDLType = Union[Type[PreElabRDLValue], 'ArrayPlaceholder']
+    PreElabRDLType = Union[Type[PreElabRDLValue], 'ArrayedType']
 else:
     # Stub on 3.5.3 or older due to: https://github.com/python/typing/issues/266
     PreElabRDLType = Any # type: ignore
diff --git a/test/test_expressions.py b/test/test_expressions.py
@@ -56,11 +56,11 @@ def test_builtin(self):
 #===============================================================================
 class TestArrayLiteral(RDLSourceTestCase):
     def test_valid(self):
-        self.assertEqual((rdlt.ArrayPlaceholder(None), []), self.eval_RDL_expr("('{})"))
-        self.assertEqual((rdlt.ArrayPlaceholder(int), [1,2,3,4]), self.eval_RDL_expr("('{1,2,3,4})"))
-        self.assertEqual((rdlt.ArrayPlaceholder(str), ["foo", "bar", "baz"]), self.eval_RDL_expr('(\'{"foo", "bar", "baz"})'))
+        self.assertEqual((rdlt.ArrayedType(None), []), self.eval_RDL_expr("('{})"))
+        self.assertEqual((rdlt.ArrayedType(int), [1,2,3,4]), self.eval_RDL_expr("('{1,2,3,4})"))
+        self.assertEqual((rdlt.ArrayedType(str), ["foo", "bar", "baz"]), self.eval_RDL_expr('(\'{"foo", "bar", "baz"})'))
         self.assertEqual(
-            (rdlt.ArrayPlaceholder(rdlt.AccessType), [rdlt.AccessType.rw, rdlt.AccessType.na]),
+            (rdlt.ArrayedType(rdlt.AccessType), [rdlt.AccessType.rw, rdlt.AccessType.na]),
             self.eval_RDL_expr("('{rw, na})")
         )
 
@@ -553,8 +553,8 @@ def test_basic(self):
         self.assertEqual((int, 456), self.eval_RDL_expr("0 ? 123 : 456"))
         self.assertEqual((int, 1), self.eval_RDL_expr("true ? true : false"))
         self.assertEqual((int, 0), self.eval_RDL_expr("false ? true : false"))
-        self.assertEqual((rdlt.ArrayPlaceholder(str), ['foo','bar']), self.eval_RDL_expr('true ? \'{"foo", "bar"} : \'{"baz"}'))
-        self.assertEqual((rdlt.ArrayPlaceholder(str), ['baz']), self.eval_RDL_expr('false ? \'{"foo", "bar"} : \'{"baz"}'))
+        self.assertEqual((rdlt.ArrayedType(str), ['foo','bar']), self.eval_RDL_expr('true ? \'{"foo", "bar"} : \'{"baz"}'))
+        self.assertEqual((rdlt.ArrayedType(str), ['baz']), self.eval_RDL_expr('false ? \'{"foo", "bar"} : \'{"baz"}'))
 
     def test_right_associative(self):
         # A ? B : C ? D : E
diff --git a/test/test_udp.py b/test/test_udp.py
@@ -4,7 +4,7 @@
 from systemrdl.messages import RDLCompileError
 from systemrdl import component as comp
 from systemrdl.udp import UDPDefinition
-from systemrdl.rdltypes import NoValue
+from systemrdl.rdltypes import NoValue, ArrayedType, RefType
 
 this_dir = os.path.dirname(os.path.realpath(__file__))
 
@@ -259,3 +259,32 @@ def test_udp_arrays(self):
                 sub3.get_property('ref_array'),
                 [a_f1, x_f2]
             )
+
+    def test_builtin_udp_arrays(self):
+        class RefArrayUDP(UDPDefinition):
+            name = "ref_array"
+            valid_type = ArrayedType(RefType)
+            valid_components = {comp.Addrmap}
+
+        class RegArrayUDP(UDPDefinition):
+            name = "reg_array"
+            valid_type = ArrayedType(comp.Reg)
+            valid_components = {comp.Addrmap}
+
+        class FieldArrayUDP(UDPDefinition):
+            name = "field_array"
+            valid_type = ArrayedType(comp.Field)
+            valid_components = {comp.Addrmap}
+
+        class IntArrayUDP(UDPDefinition):
+            name = "int_array"
+            valid_type = ArrayedType(int)
+            valid_components = {comp.Addrmap}
+
+        rdlc = RDLCompiler()
+        rdlc.register_udp(RefArrayUDP)
+        rdlc.register_udp(RegArrayUDP)
+        rdlc.register_udp(FieldArrayUDP)
+        rdlc.register_udp(IntArrayUDP)
+        rdlc.compile_file(os.path.join(this_dir, "rdl_src/udp_arrays.rdl"))
+        root = rdlc.elaborate("top")

Original file line number	Diff line number	Diff line change
`@@ -54,12 +54,12 @@ def predict_type(self) -> 'PreElabRDLType':`
`54`	`54`	`)`
`55`	`55`
`56`	`56`	`array_type = self.array.predict_type()`
`57`		`- if not isinstance(array_type, rdltypes.ArrayPlaceholder):`
	`57`	`+ if not isinstance(array_type, rdltypes.ArrayedType):`
`58`	`58`	`self.msg.fatal(`
`59`	`59`	`"Cannot index non-array type",`
`60`	`60`	`self.array.src_ref`
`61`	`61`	`)`
`62`		`- assert isinstance(array_type, rdltypes.ArrayPlaceholder)`
	`62`	`+ assert isinstance(array_type, rdltypes.ArrayedType)`
`63`	`63`
`64`	`64`	`return array_type.element_type`
`65`	`65`