chore: Refactor tuple nodes and access (#963)

As discussed in the PR (See #918 and [this
thread](#918 (comment)))
regarding group annotations, this refactors the current usages of the
Tuple nodes to a more general `Struct` which allows field access as
well.

Tuples are currently used in two places, namely `LetExpr`essions and
`LetStatements` as well as `Status` types. For `Let` nodes, the result
of the value expression may have a `StructType` with fields `result` and
`status`. E.g.:

```vadl
let next, status = VADL::adds(PC, 4 as Bits<32>) in
  if status.zero then
  PC := next
```

During behavior lowering the name `next` will be mapped to a
`StructGetFieldNode`, accessing the field `result` on the expression
`VADL::adds(PC, 4 as Bits<32>)`.

`StatusType` now exposes fields `negative`, `zero`, `carry` and
`overflow`, as opposed to positional indexing.

Author: rascmatt

vadl/main/vadl/ast/BehaviorLowering.java

@@ -48,6 +48,7 @@
 import vadl.types.DataType;
 import vadl.types.MicroArchitectureType;
 import vadl.types.SIntType;
+import vadl.types.StatusType;
 import vadl.types.Type;
 import vadl.types.UIntType;
 import vadl.utils.BigIntUtils;
@@ -108,9 +109,9 @@
 import vadl.viam.graph.dependency.SignExtendNode;
 import vadl.viam.graph.dependency.SliceNode;
 import vadl.viam.graph.dependency.StageEffectNode;
+import vadl.viam.graph.dependency.StructGetFieldNode;
 import vadl.viam.graph.dependency.TensorNode;
 import vadl.viam.graph.dependency.TruncateNode;
-import vadl.viam.graph.dependency.TupleGetFieldNode;
 import vadl.viam.graph.dependency.WriteArtificialResNode;
 import vadl.viam.graph.dependency.WriteMemNode;
 import vadl.viam.graph.dependency.WriteRegTensorNode;
@@ -781,7 +782,6 @@ private SubgraphContext fetch(Statement stmt) {
   }
 
 
-
   /// This utility function can be used to fill in missing indexes of a tensor.
   ///
   /// It basically returns a permutation of all possible indices for the dimensions provided.
@@ -1067,19 +1067,18 @@ private ExpressionNode visitIdentifyable(Expr expr) {
     // Let statement and expression
     if (computedTarget instanceof LetStatement letStatement) {
       var expression = fetch(letStatement.valueExpr);
-      var index = letStatement.getIndexOf(innerName);
       if (letStatement.identifiers.size() > 1) {
-        expression = new TupleGetFieldNode(index, expression,
+        expression = new StructGetFieldNode(letStatement.mapName(innerName), expression,
             getViamType(letStatement.getTypeOf(innerName)));
       }
       return new LetNode(new LetNode.Name(innerName, letStatement.location()), expression);
     }
     if (computedTarget instanceof LetExpr letExpr) {
       var expression = fetch(letExpr.valueExpr);
-      var index = letExpr.getIndexOf(innerName);
       if (letExpr.identifiers.size() > 1) {
         expression =
-            new TupleGetFieldNode(index, expression, getViamType(letExpr.getTypeOf(innerName)));
+            new StructGetFieldNode(letExpr.mapName(innerName), expression,
+                getViamType(letExpr.getTypeOf(innerName)));
       }
       return new LetNode(new LetNode.Name(innerName, letExpr.location()), expression);
     }
@@ -1173,7 +1172,7 @@ public ExpressionNode visit(GroupedExpr expr) {
 
     var type = expr.type().equals(Type.string()) ? expr.type() :
         Type.bits(expr.expressions.get(0).type().asDataType()
-            .bitWidth() + expr.expressions.get(1).type().asDataType().bitWidth());
+                  .bitWidth() + expr.expressions.get(1).type().asDataType().bitWidth());
 
     var call = new BuiltInCall(concatBuiltin,
         new NodeList<>(expr.expressions.get(0).accept(this),
@@ -1183,7 +1182,7 @@ public ExpressionNode visit(GroupedExpr expr) {
     for (int i = 2; i < expr.expressions.size(); i++) {
       type = expr.type().equals(Type.string()) ? expr.type() :
           Type.bits(type.asDataType().bitWidth()
-              + expr.expressions.get(i).type().asDataType().bitWidth());
+                    + expr.expressions.get(i).type().asDataType().bitWidth());
       call = new BuiltInCall(concatBuiltin,
           new NodeList<>(call,
               expr.expressions.get(i).accept(this)),
@@ -1284,9 +1283,8 @@ private ExpressionNode visitSubCall(CallIndexExpr expr, ExpressionNode exprBefor
                 (DataType) getViamType(requireNonNull(subCall.formatFieldType)));
         resultExpr =
             visitSliceIndexCall(slice, subCall.formatFieldType, subCall.argsIndices);
-      } else if (subCall.computedStatusIndex != null) {
-        var indexing =
-            new TupleGetFieldNode(subCall.computedStatusIndex, resultExpr, Type.bool());
+      } else if (exprBeforeSubcall.type() instanceof StatusType) {
+        var indexing = new StructGetFieldNode(subCall.identifier().name, resultExpr, Type.bool());
         resultExpr = visitSliceIndexCall(indexing, Type.bool(), subCall.argsIndices);
       } else if (exprBeforeSubcall.type() == MicroArchitectureType.instruction()) {
         // There is weired way to call functions on instructions
@@ -1413,7 +1411,7 @@ public ExpressionNode visitStageCall(CallIndexExpr expr, StageDefinition stageDe
             .filter(o -> o.identifier().name.equals(subcall.identifier().name))
             .findFirst()
             .get()
-        ).get();
+    ).get();
     return new ReadStageOutputNode(output);
   }
 
@@ -1811,10 +1809,10 @@ public SubgraphContext visit(AssignmentStatement statement) {
   /**
    * Method that prepares the value so that it can be used for a dynamic write of a resource.
    *
-   * @param value       value that is being written (right side of assignment)
-   * @param entireRead  resource value before value is written
-   * @param index       the dynamic expression of the index.
-   * @return            that incorporates the written value into the resource.
+   * @param value      value that is being written (right side of assignment)
+   * @param entireRead resource value before value is written
+   * @param index      the dynamic expression of the index.
+   * @return that incorporates the written value into the resource.
    */
   private ExpressionNode dynamicIndexWriteValue(ExpressionNode value, ReadResourceNode entireRead,
                                                 @Nullable ExpressionNode index) {

vadl/main/vadl/ast/ConstantEvaluator.java

@@ -199,9 +199,9 @@ private ConstantValue visitIdentifiable(Expr expr) {
     }
 
     if (origin instanceof LetExpr letExpr) {
-      // FIXME: implement tuple unpacking
+      // FIXME: implement field unpacking
       if (letExpr.identifiers.size() > 1) {
-        throw new EvaluationError("Cannot evaluate tuple unpacking yet",
+        throw new EvaluationError("Cannot evaluate field unpacking yet",
             letExpr.identifiers().getFirst().loc.join(
                 letExpr.identifiers().getLast().loc));
       }

vadl/main/vadl/ast/Expr.java

@@ -31,7 +31,7 @@
 import vadl.types.BuiltInTable;
 import vadl.types.ConcreteRelationType;
 import vadl.types.SIntType;
-import vadl.types.TupleType;
+import vadl.types.StructType;
 import vadl.types.Type;
 import vadl.types.UIntType;
 import vadl.utils.SourceLocation;
@@ -2030,13 +2030,6 @@ static final class SubCall implements WithLocation {
     @Nullable
     Constant.BitSlice computedBitSlice;
 
-    /**
-     * If the subcall is status access, this field tells which index in the status type the
-     * field is.
-     */
-    @Nullable
-    public Integer computedStatusIndex;
-
     SubCall(IdentifierOrPlaceholder id, List<Arguments> argsIndices) {
       this.id = id;
       this.argsIndices = argsIndices;
@@ -2169,16 +2162,34 @@ List<Identifier> identifiers() {
   }
 
   /**
-   * Returns the index of one of the variables the statement defines.
+   * Translates the outer name of the let expression to the inner name of the value expression.
+   * E.g.:
    *
-   * @return the type of the name provided.
+   * <pre>
+   *   let next, status = VADL::adds(PC, 4 as Bits<32>) in
+   *       ...
+   * </pre>
+   * this method will translate "next" to "result" and "status" to "status".
+   *
+   * @param name the bound name of the let expression.
+   * @return the name of the value expression.
    */
-  int getIndexOf(String name) {
-    return identifiers().stream().map(i -> i.name).toList().indexOf(name);
+  String mapName(String name) {
+    var valType = valueExpr.type;
+    if (!(valType instanceof StructType struct)) {
+      throw new IllegalStateException("Expected StructType but got " + valType);
+    }
+    final List<String> fields = struct.fieldNames();
+    for (var i = 0; i < identifiers.size(); i++) {
+      if (name.equals(identifiers().get(i).name)) {
+        return fields.get(i);
+      }
+    }
+    throw new IllegalStateException("Let expression does not have a name `%s`.".formatted(name));
   }
 
   /**
-   * Returns the type of one of the variables the statement defines.
+   * Returns the type of one of the variables the expression defines.
    *
    * @return the type of the name provided.
    */
@@ -2188,11 +2199,11 @@ Type getTypeOf(String name) {
       return requireNonNull(valType);
     }
 
-    if (!(valType instanceof TupleType valTuple)) {
-      throw new IllegalStateException("Expected TupleType but got " + valType);
+    if (!(valType instanceof StructType valStruct)) {
+      throw new IllegalStateException("Expected StructType but got " + valType);
     }
 
-    return requireNonNull(valTuple.get(getIndexOf(name)));
+    return requireNonNull(valStruct.get(mapName(name)));
   }
 
   @Override

vadl/main/vadl/ast/Statement.java

@@ -23,7 +23,7 @@
 import java.util.function.Consumer;
 import javax.annotation.Nullable;
 import vadl.javaannotations.ast.Child;
-import vadl.types.TupleType;
+import vadl.types.StructType;
 import vadl.types.Type;
 import vadl.utils.SourceLocation;
 import vadl.utils.WithLocation;
@@ -124,7 +124,7 @@ <R> R accept(StatementVisitor<R> visitor) {
 }
 
 /**
- * If multiple identifiers are provided, they are used to unpack a tuple.
+ * If multiple identifiers are provided, they are used to unpack fields of a struct.
  */
 final class LetStatement extends Statement {
   List<IsId> identifiers;
@@ -147,18 +147,31 @@ List<Identifier> identifiers() {
   }
 
   /**
-   * Returns the index of one of the variables the statement defines.
+   * Translates the outer name of the let statement to the inner name of the value expression.
+   * E.g.:
    *
-   * @return the index/offset of the name provided.
+   * <pre>
+   *   let next, status = VADL::adds(PC, 4 as Bits<32>) in
+   *       ...
+   * </pre>
+   * this method will translate "next" to "result" and "status" to "status".
+   *
+   * @param name the bound name of the let statement.
+   * @return the name of the value expression.
    */
-  int getIndexOf(String name) {
-    for (var idx = 0; idx < identifiers.size(); idx++) {
-      if (((Identifier) identifiers.get(idx)).name.equals(name)) {
-        return idx;
-      }
+  String mapName(String name) {
+    var valType = valueExpr.type;
+    if (!(valType instanceof StructType struct)) {
+      throw new IllegalStateException("Expected StructType but got " + valType);
     }
 
-    return -1;
+    final List<String> fields = struct.fieldNames();
+    for (var i = 0; i < identifiers.size(); i++) {
+      if (name.equals(identifiers().get(i).name)) {
+        return fields.get(i);
+      }
+    }
+    throw new IllegalStateException("Let statement does not have a name `%s`.".formatted(name));
   }
 
   /**
@@ -172,11 +185,11 @@ Type getTypeOf(String name) {
       return Objects.requireNonNull(valType);
     }
 
-    if (!(valType instanceof TupleType valTuple)) {
-      throw new IllegalStateException("Expected TupleType but got " + valType);
+    if (!(valType instanceof StructType valStruct)) {
+      throw new IllegalStateException("Expected StructType but got " + valType);
     }
 
-    return Objects.requireNonNull(valTuple.get(getIndexOf(name)));
+    return Objects.requireNonNull(valStruct.fields().get(mapName(name)));
   }
 
   @Override

vadl/main/vadl/ast/TypeChecker.java

@@ -55,7 +55,7 @@
 import vadl.types.SIntType;
 import vadl.types.StatusType;
 import vadl.types.StringType;
-import vadl.types.TupleType;
+import vadl.types.StructType;
 import vadl.types.Type;
 import vadl.types.UIntType;
 import vadl.types.asmTypes.AsmType;
@@ -3762,7 +3762,6 @@ private void visitSubCall(CallIndexExpr expr, Type typeBeforeSubCall) {
               .build());
         }
         var fieldType = Type.bool();
-        subCall.computedStatusIndex = allowedStatusfields.indexOf(fieldName);
         visitSliceIndexCall(expr, fieldType, subCall.argsIndices);
         type = expr.type;
       } else if (type instanceof InstructionType) {
@@ -4085,23 +4084,24 @@ public Void visit(LetExpr expr) {
     var valType = check(expr.valueExpr);
 
     if (expr.identifiers.size() > 1) {
-      if (!(valType instanceof TupleType valTupleType)) {
-        var loc = expr.identifiers().get(0).loc.join(expr.valueExpr.location());
+      if (!(valType instanceof StructType valStructType)) {
+        var loc = expr.identifiers().getFirst().loc.join(expr.valueExpr.location());
         throw addErrorAndStopChecking(error("Type Mismatch", loc)
-            .description("Tuple unpacking only works on tuples but the type was `%s`", valType)
+            .description("Field unpacking only works on structs but the type was `%s`", valType)
             .build());
       }
 
-      if (expr.identifiers.size() != valTupleType.size()) {
-        var loc = expr.identifiers().get(0).loc.join(expr.valueExpr.location());
-        addErrorAndStopChecking(error("Invalid Tuple Unpacking", loc)
-            .description("Cannot unpack %d values form a `%s`.", expr.identifiers.size(),
+      if (expr.identifiers.size() != valStructType.size()) {
+        var loc = expr.identifiers().getFirst().loc.join(expr.valueExpr.location());
+        throw addErrorAndStopChecking(error("Invalid Field Unpacking", loc)
+            .description("Cannot unpack %d values from a `%s`.", expr.identifiers.size(),
                 valType)
             .build());
       }
 
+      var valTypes = valStructType.types();
       for (int i = 0; i < expr.identifiers.size(); i++) {
-        expr.identifiers().get(i).type = valTupleType.get(i);
+        expr.identifiers().get(i).type = valTypes.get(i);
       }
     } else {
       expr.identifiers().getFirst().type = valType;
@@ -4365,23 +4365,24 @@ public Void visit(LetStatement statement) {
     var valType = check(statement.valueExpr);
 
     if (statement.identifiers.size() > 1) {
-      if (!(valType instanceof TupleType valTupleType)) {
-        var loc = statement.identifiers().get(0).loc.join(statement.valueExpr.location());
+      if (!(valType instanceof StructType valStructType)) {
+        var loc = statement.identifiers().getFirst().loc.join(statement.valueExpr.location());
         throw addErrorAndStopChecking(error("Type Mismatch", loc)
-            .description("Tuple unpacking only works on tuples but the type was `%s`", valType)
+            .description("Field unpacking only works on structs but the type was `%s`", valType)
             .build());
       }
 
-      if (statement.identifiers.size() != valTupleType.size()) {
-        var loc = statement.identifiers().get(0).loc.join(statement.valueExpr.location());
-        addErrorAndStopChecking(error("Invalid Tuple Unpacking", loc)
-            .description("Cannot unpack %d values form a `%s`.", statement.identifiers.size(),
+      if (statement.identifiers.size() != valStructType.size()) {
+        var loc = statement.identifiers().getFirst().loc.join(statement.valueExpr.location());
+        throw addErrorAndStopChecking(error("Invalid Field Unpacking", loc)
+            .description("Cannot unpack %d values from a `%s`.", statement.identifiers.size(),
                 valType)
             .build());
       }
 
+      var valTypes = valStructType.types();
       for (int i = 0; i < statement.identifiers.size(); i++) {
-        statement.identifiers().get(i).type = valTupleType.get(i);
+        statement.identifiers().get(i).type = valTypes.get(i);
       }
     } else {
       statement.identifiers().getFirst().type = valType;

vadl/main/vadl/cppCodeGen/mixins/CDefaultMixins.java

@@ -56,9 +56,9 @@
 import vadl.viam.graph.dependency.SelectNode;
 import vadl.viam.graph.dependency.SignExtendNode;
 import vadl.viam.graph.dependency.SliceNode;
+import vadl.viam.graph.dependency.StructGetFieldNode;
 import vadl.viam.graph.dependency.TensorNode;
 import vadl.viam.graph.dependency.TruncateNode;
-import vadl.viam.graph.dependency.TupleGetFieldNode;
 import vadl.viam.graph.dependency.ZeroExtendNode;
 import vadl.viam.passes.sideEffectScheduling.nodes.InstrExitNode;
 
@@ -328,7 +328,7 @@ interface AllDependencies extends AllExpressions {
   @SuppressWarnings("MissingJavadocType")
   interface AllExpressions
       extends TypeCasts, Constant, FuncCall, BuiltIns, Slice, LetNode, Select, FuncParam, ForallIdx,
-      TupleAccess, Label {
+      FieldAccess, Label {
 
   }
 
@@ -449,10 +449,10 @@ default void handle(CGenContext<Node> ctx, SelectNode toHandle) {
   }
 
   @SuppressWarnings("MissingJavadocType")
-  interface TupleAccess {
+  interface FieldAccess {
     @Handler
-    default void handle(CGenContext<Node> ctx, TupleGetFieldNode toHandle) {
-      throw new UnsupportedOperationException("Type TupleGetFieldNode not yet implemented");
+    default void handle(CGenContext<Node> ctx, StructGetFieldNode toHandle) {
+      throw new UnsupportedOperationException("Type StructGetFieldNode not yet implemented");
     }
   }