Prevent too long string representation of enumeration

Ref. #799

rflx/model/type_.py

@@ -4,7 +4,7 @@
 
 import rflx.typing_ as rty
 from rflx import const, expression as expr
-from rflx.common import verbose_repr
+from rflx.common import indent_next, verbose_repr
 from rflx.error import Location, Severity, Subsystem
 from rflx.identifier import ID, StrID
 
@@ -462,7 +462,14 @@ def __repr__(self) -> str:
     def __str__(self) -> str:
         literals = ", ".join(f"{l} => {v}" for l, v in self.literals.items())
         always_valid = f", Always_Valid => {self.always_valid}" if self.always_valid else ""
-        return f"type {self.name} is ({literals}) with Size => {self.size_expr}{always_valid}"
+        aspects = f"with Size => {self.size_expr}{always_valid}"
+        result = f"type {self.name} is ({literals}) {aspects}"
+
+        if len(result) > 100:
+            literals = ",\n".join(f"{l} => {v}" for l, v in self.literals.items())
+            result = f"type {self.name} is\n   ({indent_next(literals, 4)})\n{aspects}"
+
+        return result
 
     @property
     def type_(self) -> rty.Type:

tests/unit/model/type_test.py

@@ -335,6 +335,44 @@ def test_enumeration_invalid_multiple_duplicate_elements() -> None:
     )
 
 
+def test_enumeration_str() -> None:
+    assert (
+        str(
+            Enumeration(
+                "P::T",
+                [("A", Number(1))],
+                Pow(Number(2), Number(5)),
+                always_valid=False,
+            )
+        )
+        == "type T is (A => 1) with Size => 2 ** 5"
+    )
+    assert str(
+        Enumeration(
+            "P::T",
+            [
+                ("A", Number(2 ** 2)),
+                ("B", Number(2 ** 3)),
+                ("C", Number(2 ** 4)),
+                ("D", Number(2 ** 5)),
+                ("E", Number(2 ** 6)),
+                ("F", Number(2 ** 7)),
+            ],
+            Pow(Number(2), Number(8)),
+            always_valid=True,
+        )
+    ) == (
+        "type T is\n"
+        "   (A => 4,\n"
+        "    B => 8,\n"
+        "    C => 16,\n"
+        "    D => 32,\n"
+        "    E => 64,\n"
+        "    F => 128)\n"
+        "with Size => 2 ** 8, Always_Valid => True"
+    )
+
+
 def test_sequence_dependencies() -> None:
     assert models.SEQUENCE_MODULAR_VECTOR.dependencies == [
         models.SEQUENCE_MODULAR_VECTOR,