Add qualified expression

Ref. #691

rflx/ada.py

@@ -977,7 +977,7 @@ def precedence(self) -> Precedence:
         raise NotImplementedError
 
     def rflx_expr(self) -> expr.Expr:
-        raise NotImplementedError
+        return expr.QualifiedExpr(ID(self.type_identifier), self.expression.rflx_expr())
 
 
 class Raise(Expr):

rflx/expression.py

@@ -2447,6 +2447,42 @@ def variables(self) -> List["Variable"]:
         return self.argument.variables()
 
 
+class QualifiedExpr(Expr):
+    """Only used by code generator and therefore provides minimum functionality."""
+
+    def __init__(self, type_identifier: StrID, expression: Expr) -> None:
+        super().__init__()
+        self.type_identifier = ID(type_identifier)
+        self.expression = expression
+
+    def __neg__(self) -> Expr:
+        raise NotImplementedError
+
+    def _update_str(self) -> None:
+        operand = (
+            str(self.expression)
+            if isinstance(self.expression, (Aggregate, NamedAggregate))
+            else f"({self.expression})"
+        )
+        self._str = intern(f"{self.type_identifier}'{operand}")
+
+    def _check_type_subexpr(self) -> RecordFluxError:
+        raise NotImplementedError
+
+    @property
+    def precedence(self) -> Precedence:
+        raise NotImplementedError
+
+    def simplified(self) -> Expr:
+        return QualifiedExpr(self.type_identifier, self.expression.simplified())
+
+    def ada_expr(self) -> ada.Expr:
+        return ada.QualifiedExpr(ada.ID(self.type_identifier), self.expression.ada_expr())
+
+    def z3expr(self) -> z3.ArithRef:
+        raise NotImplementedError
+
+
 class Comprehension(Expr):
     def __init__(
         self,

tests/unit/ada_test.py

@@ -747,6 +747,12 @@ def test_qualified_expr() -> None:
     assert str(ada.QualifiedExpr("T", ada.Variable("A"))) == "T'(A)"
 
 
+def test_qualified_expr_rflx_expr() -> None:
+    assert ada.QualifiedExpr("X", ada.Variable("Y")).rflx_expr() == expr.QualifiedExpr(
+        "X", expr.Variable("Y")
+    )
+
+
 def test_parameter() -> None:
     assert str(ada.Parameter(["P1"], "T")) == "P1 : T"
     assert str(ada.Parameter(["P1"], ada.ID("Boolean"))) == "P1 : Boolean"

tests/unit/expression_test.py

@@ -56,6 +56,7 @@
     Present,
     Proof,
     ProofResult,
+    QualifiedExpr,
     Rem,
     Selected,
     Size,
@@ -1916,6 +1917,16 @@ def test_conversion_ada_expr() -> None:
     assert Conversion("X", Variable("Y")).ada_expr() == ada.Conversion("X", ada.Variable("Y"))
 
 
+def test_qualified_expr_simplified() -> None:
+    assert QualifiedExpr("X", Add(Number(21), Number(21))).simplified() == QualifiedExpr(
+        "X", Number(42)
+    )
+
+
+def test_qualified_expr_ada_expr() -> None:
+    assert QualifiedExpr("X", Variable("Y")).ada_expr() == ada.QualifiedExpr("X", ada.Variable("Y"))
+
+
 def test_comprehension_type() -> None:
     assert_type(
         Comprehension(