Added support for Tuples (hkust-taco#374)

Author: FetBoba

hkmc2/shared/src/main/scala/hkmc2/codegen/wasm/text/Ctx.scala

@@ -128,6 +128,9 @@ class TypeInfo(
       doc"(type${idDoc.surroundUnlessEmpty(doc" ")} ${compType.toWat})"
 end TypeInfo
 
+enum WasmIntrinsicType:
+  case TupleArray(mutable: Bool)
+
 object Ctx:
   val binaryOps: Map[Str, (Expr, Expr) => Expr] = Map(
     "plus_impl" -> i32.add,
@@ -192,6 +195,7 @@ class Ctx(
   import Ctx.prettyString
 
   private val wasmIntrinsicFuncs: MutMap[Str, FuncIdx] = MutMap.empty
+  private val wasmIntrinsicTypes: MutMap[WasmIntrinsicType, TypeIdx] = MutMap.empty
 
   /** Adds a type into this context. */
   def addType(sym: Opt[BlockMemberSymbol], typeInfo: TypeInfo): TypeIdx =
@@ -324,6 +328,13 @@ class Ctx(
   def getOrCreateWasmIntrinsic(name: Str, createIntrinsic: => FuncIdx): FuncIdx =
     wasmIntrinsicFuncs.getOrElseUpdate(name, createIntrinsic)
 
+  /**
+   * Returns the cached [[TypeIdx]] for the intrinsic type `key`, creating it with `createType` if
+   * it does not yet exist in this context.
+   */
+  def getOrCreateWasmIntrinsicType(key: WasmIntrinsicType, createType: => TypeIdx): TypeIdx =
+    wasmIntrinsicTypes.getOrElseUpdate(key, createType)
+
   def toWat: Document =
     doc"(module #{  # ${(types.toSeq ++ funcs.toSeq).map(_.toWat).mkDocument(doc" # ")}) #} "
 

hkmc2/shared/src/main/scala/hkmc2/codegen/wasm/text/Instructions.scala

@@ -243,6 +243,30 @@ object Instructions:
       stackargs = Seq(arrayRef),
       resultType = S(I32Type)
     )
+
+    /** Creates an `array.new_fixed` instruction. */
+    def new_fixed(arrayType: TypeIdx, items: Seq[Expr]): FoldedInstr = FoldedInstr(
+      mnemonic = "array.new_fixed",
+      instrargs = Seq(arrayType.toWat, doc"${items.length}"),
+      stackargs = items,
+      resultType = S(RefType(arrayType, nullable = false))
+    )
+
+    /** Creates an `array.get` instruction. */
+    def get(arrayType: TypeIdx, arrayRef: Expr, index: Expr, elemType: Type): FoldedInstr = FoldedInstr(
+      mnemonic = "array.get",
+      instrargs = Seq(arrayType.toWat),
+      stackargs = Seq(arrayRef, index),
+      resultType = S(elemType)
+    )
+
+    /** Creates an `array.set` instruction. */
+    def set(arrayType: TypeIdx, arrayRef: Expr, index: Expr, value: Expr): FoldedInstr = FoldedInstr(
+      mnemonic = "array.set",
+      instrargs = Seq(arrayType.toWat),
+      stackargs = Seq(arrayRef, index, value),
+      resultType = N
+    )
   end array
 
   object ref:
@@ -300,6 +324,14 @@ object Instructions:
       resultType = S(ty)
     )
 
+    /** Creates a `local.tee` instruction. */
+    def tee(index: LocalIdx, value: Expr): FoldedInstr = FoldedInstr(
+      mnemonic = "local.tee",
+      instrargs = Seq(index),
+      stackargs = Seq(value),
+      resultTypes = value.resultTypes
+    )
+
     /** Creates a `local.set` instruction. */
     def set(index: LocalIdx, value: Expr): FoldedInstr = FoldedInstr(
       mnemonic = "local.set",

hkmc2/shared/src/main/scala/hkmc2/codegen/wasm/text/Wasm.scala

@@ -135,8 +135,19 @@ case class StructType(
   def toWat: Document =
     doc"(struct${fieldSeq.map(_.toWat).mkDocument(doc" ").surroundUnlessEmpty(doc" ")})"
 
+/** A type representing an array type. */
+case class ArrayType(
+    elemType: Type,
+    mutable: Bool,
+) extends ToWat:
+  private def elemDoc: Document =
+    if mutable then doc"(mut ${elemType.toWat})" else elemType.toWat
+
+  def toWat: Document =
+    doc"(array ${elemDoc})"
+
 /** A composite type. */
-type CompType = StructType | FunctionType
+type CompType = StructType | FunctionType | ArrayType
 
 type AbsHeapType =
   HeapType.Func.type