Fix interpretation of function calls without arguments

Ref. #763

rflx/generator/session.py

@@ -847,6 +847,14 @@ def _declare(
     ) -> EvaluatedDeclaration:
         result = EvaluatedDeclaration()
 
+        if expression:
+            for e in expression.findall(lambda x: isinstance(x, expr.Call)):
+                fail(
+                    "initialization using function call not yet supported",
+                    Subsystem.GENERATOR,
+                    location=e.location,
+                )
+
         if type_ == rty.OPAQUE:
             initialization = expression
             object_type: Expr = Variable(const.TYPES_BYTES)

rflx/model/session.py

@@ -170,6 +170,8 @@ def __init__(
             **mty.enum_literals(self.types.values(), self.package),
         }
 
+        self._resolve_function_calls()
+
         self.error.propagate()
 
     def __repr__(self) -> str:
@@ -185,6 +187,38 @@ def __str__(self) -> str:
             f"is\n{indent(declarations, 3)}begin\n{indent(states, 3)}\nend {self.identifier.name}"
         )
 
+    def _resolve_function_calls(self) -> None:
+        """
+        Replace variables by function calls where necessary.
+
+        The distinction between function calls without arguments and variables is not possible in
+        the parser, as both are syntactically identical.
+        """
+        functions = [
+            p.identifier
+            for p in self.parameters.values()
+            if isinstance(p, decl.FunctionDeclaration)
+        ]
+
+        def substitution(expression: expr.Expr) -> expr.Expr:
+            if isinstance(expression, expr.Variable) and expression.identifier in functions:
+                return expr.Call(expression.identifier, location=expression.location)
+            return expression
+
+        for d in self.declarations.values():
+            if isinstance(d, decl.VariableDeclaration) and d.expression:
+                d.expression = d.expression.substituted(substitution)
+
+        for state in self.states:
+            for d in state.declarations.values():
+                if isinstance(d, decl.VariableDeclaration) and d.expression:
+                    d.expression = d.expression.substituted(substitution)
+            for s in state.actions:
+                if isinstance(s, stmt.Assignment):
+                    s.expression = s.expression.substituted(substitution)
+                if isinstance(s, stmt.AttributeStatement):
+                    s.parameters = [p.substituted(substitution) for p in s.parameters]
+
 
 class Session(AbstractSession):
     # pylint: disable=too-many-arguments

tests/unit/generator_test.py

@@ -1026,6 +1026,12 @@ def test_session_declare(
 @pytest.mark.parametrize(
     "type_, expression, error_type, error_msg",
     [
+        (
+            rty.Integer("T"),
+            expr.Call("F", location=Location((10, 20))),
+            RecordFluxError,
+            r"initialization using function call not yet supported",
+        ),
         (
             rty.Message("T"),
             expr.BooleanTrue(location=Location((10, 20))),

tests/unit/model/session_test.py

@@ -2102,3 +2102,51 @@ def test_unnecessary_exception_transition() -> None:
         types=[],
         regex=r'^<stdin>:10:20: model: error: unnecessary exception transition in state "Start"$',
     )
+
+
+def test_resolving_of_function_calls() -> None:
+    session = Session(
+        identifier="P::S",
+        initial=ID("Start"),
+        final=ID("End"),
+        states=[
+            State(
+                "Start",
+                declarations=[
+                    decl.VariableDeclaration("Local", "Boolean", expr.Variable("Func")),
+                ],
+                actions=[
+                    stmt.Assignment("Global", expr.Variable("Func")),
+                ],
+                transitions=[
+                    Transition(
+                        target=ID("End"),
+                        condition=expr.And(expr.Variable("Global"), expr.Variable("Local")),
+                    ),
+                    Transition(
+                        target=ID("End"),
+                    ),
+                ],
+            ),
+            State("End"),
+        ],
+        declarations=[
+            decl.VariableDeclaration("Global", "Boolean", expr.Variable("Func")),
+        ],
+        parameters=[
+            decl.FunctionDeclaration("Func", [], "Boolean"),
+        ],
+        types=[BOOLEAN, OPAQUE, TLV_MESSAGE],
+    )
+
+    global_decl = session.declarations[ID("Global")]
+    assert isinstance(global_decl, decl.VariableDeclaration)
+    assert global_decl.expression == expr.Call("Func")
+
+    local_decl = session.states[0].declarations[ID("Local")]
+    assert isinstance(local_decl, decl.VariableDeclaration)
+    assert local_decl.expression == expr.Call("Func")
+
+    local_stmt = session.states[0].actions[0]
+    assert isinstance(local_stmt, stmt.Assignment)
+    assert local_stmt.expression == expr.Call("Func")