Replace StateName by ID

Ref. #47, #382

rflx/session.py

@@ -16,22 +16,8 @@
 from rflx.statement import Statement
 
 
-class StateName(Base):
-    def __init__(self, name: str, location: Location = None):
-        self.name = name
-        self.location = location
-
-    def __hash__(self) -> int:
-        return hash(self.name)
-
-    def __lt__(self, other: object) -> bool:
-        if isinstance(other, StateName):
-            return self.name < other.name
-        return NotImplemented
-
-
 class Transition(Base):
-    def __init__(self, target: StateName, condition: Expr = TRUE, location: Location = None):
+    def __init__(self, target: ID, condition: Expr = TRUE, location: Location = None):
         self.target = target
         self.condition = condition
         self.location = location
@@ -43,7 +29,7 @@ def validate(self, declarations: Dict[ID, Declaration]) -> None:
 class State(Base):
     def __init__(
         self,
-        name: StateName,
+        name: ID,
         transitions: Sequence[Transition] = None,
         actions: Sequence[Statement] = None,
         declarations: Dict[StrID, Declaration] = None,
@@ -56,7 +42,7 @@ def __init__(
         self.location = location
 
     @property
-    def name(self) -> StateName:
+    def name(self) -> ID:
         return self.__name
 
     @property
@@ -72,8 +58,8 @@ class Session(Base):
     def __init__(
         self,
         name: StrID,
-        initial: StateName,
-        final: StateName,
+        initial: ID,
+        final: ID,
         states: Sequence[State],
         declarations: Dict[StrID, Declaration],
         location: Location = None,
@@ -151,8 +137,8 @@ def __validate_state_existence(self) -> None:
 
     def __validate_duplicate_states(self) -> None:
         state_names = [s.name for s in self.states]
-        seen: Dict[StateName, int] = {}
-        duplicates: List[str] = []
+        seen: Dict[ID, int] = {}
+        duplicates: List[ID] = []
         for n in state_names:
             if n not in seen:
                 seen[n] = 1
@@ -169,15 +155,15 @@ def __validate_duplicate_states(self) -> None:
             )
 
     def __validate_state_reachability(self) -> None:
-        inputs: Dict[StateName, List[StateName]] = {}
+        inputs: Dict[ID, List[ID]] = {}
         for s in self.states:
             for t in s.transitions:
                 if t.target in inputs:
                     inputs[t.target].append(s.name)
                 else:
                     inputs[t.target] = [s.name]
         unreachable = [
-            s.name.name for s in self.states if s.name != self.initial and s.name not in inputs
+            str(s.name) for s in self.states if s.name != self.initial and s.name not in inputs
         ]
         if unreachable:
             self.error.append(
@@ -187,7 +173,7 @@ def __validate_state_reachability(self) -> None:
                 self.location,
             )
 
-        detached = [s.name.name for s in self.states if s.name != self.final and not s.transitions]
+        detached = [str(s.name) for s in self.states if s.name != self.final and not s.transitions]
         if detached:
             self.error.append(
                 f'detached states {", ".join(detached)}',

rflx/sessionfile.py

@@ -6,7 +6,7 @@
 from rflx.expression import TRUE, Channel, Declaration
 from rflx.identifier import ID, StrID
 from rflx.parser.session import action, declaration, expression
-from rflx.session import Session, State, StateName, Transition
+from rflx.session import Session, State, Transition
 from rflx.statement import Statement
 
 
@@ -170,7 +170,7 @@ def __parse_transitions(self, state: Dict) -> List[Transition]:
                         condition = TRUE
                 else:
                     condition = TRUE
-                transitions.append(Transition(target=StateName(t["target"]), condition=condition))
+                transitions.append(Transition(target=ID(t["target"]), condition=condition))
         self.error.propagate()
         return transitions
 
@@ -217,7 +217,7 @@ def __parse_states(self, doc: Dict[str, Any]) -> List[State]:
 
             states.append(
                 State(
-                    name=StateName(s["name"]),
+                    name=ID(s["name"]),
                     transitions=self.__parse_transitions(s),
                     actions=actions,
                     declarations=declarations,
@@ -249,8 +249,8 @@ def __parse(self, name: str, doc: Dict[str, Any]) -> None:
 
         session = Session(
             name=name,
-            initial=StateName(doc["initial"]),
-            final=StateName(doc["final"]),
+            initial=ID(doc["initial"]),
+            final=ID(doc["final"]),
             states=self.__parse_states(doc),
             declarations={ID(k): v for k, v in self.__parse_declarations(doc).items()},
         )

tests/test_graph.py

@@ -4,7 +4,7 @@
 from rflx.expression import FALSE, TRUE, Equal, Greater, Variable, VariableDeclaration
 from rflx.graph import Graph
 from rflx.model import FINAL, INITIAL, Field, Less, Link, Message, ModularInteger, Number, Pow
-from rflx.session import Session, State, StateName, Transition
+from rflx.session import ID, Session, State, Transition
 from rflx.statement import Assignment, Erase
 from tests.utils import BASE_TMP_DIR
 
@@ -170,25 +170,23 @@ def test_dot_graph_with_double_edge() -> None:
 def test_session_graph() -> None:
     s = Session(
         name="foo",
-        initial=StateName("START"),
-        final=StateName("END"),
+        initial=ID("START"),
+        final=ID("END"),
         states=[
             State(
-                name=StateName("START"),
+                name=ID("START"),
                 transitions=[
-                    Transition(
-                        target=StateName("STATE"), condition=Equal(Variable("Global"), TRUE)
-                    ),
-                    Transition(target=StateName("END")),
+                    Transition(target=ID("STATE"), condition=Equal(Variable("Global"), TRUE)),
+                    Transition(target=ID("END")),
                 ],
             ),
             State(
-                name=StateName("STATE"),
-                transitions=[Transition(target=StateName("END"))],
+                name=ID("STATE"),
+                transitions=[Transition(target=ID("END"))],
                 actions=[Assignment("Global", FALSE), Erase("Local")],
                 declarations={"Local": VariableDeclaration("Boolean")},
             ),
-            State(name=StateName("END")),
+            State(name=ID("END")),
         ],
         declarations={"Global": VariableDeclaration("Some_Type")},
     )