boots: Add Assoc and GenericAssoc to BytecodeType

dinfuehr · Feb 1, 2025 · ac97751 · ac97751
1 parent 742aaba
commit ac97751
Show file tree

Hide file tree

Showing 9 changed files with 80 additions and 14 deletions.
diff --git a/dora-runtime/src/boots/serializer.rs b/dora-runtime/src/boots/serializer.rs
@@ -11,7 +11,7 @@ use dora_bytecode::{
     BytecodeFunction, BytecodeTypeArray, ConstPoolEntry, ConstPoolOpcode, EnumData, FunctionData,
     Location, StructData,
 };
-use dora_bytecode::{BytecodeType, BytecodeTypeKind};
+use dora_bytecode::{BytecodeTraitType, BytecodeType, BytecodeTypeKind};
 
 pub fn allocate_encoded_system_config(vm: &VM) -> Ref<UInt8Array> {
     let mut buffer = ByteBuffer::new();
@@ -276,14 +276,33 @@ fn encode_bytecode_type(vm: &VM, ty: &BytecodeType, buffer: &mut ByteBuffer) {
             encode_bytecode_type_array(vm, params, buffer);
             encode_bytecode_type(vm, ret.as_ref(), buffer);
         }
-        BytecodeType::TypeAlias(..)
-        | BytecodeType::Assoc(..)
-        | BytecodeType::GenericAssoc { .. } => {
+        BytecodeType::GenericAssoc {
+            type_param_id,
+            trait_ty,
+            assoc_id,
+        } => {
+            buffer.emit_u8(BytecodeTypeKind::GenericAssoc as u8);
+            buffer.emit_u32(*type_param_id);
+            encode_bytecode_trait_type(vm, trait_ty, buffer);
+            buffer.emit_id(assoc_id.0 as usize);
+        }
+        BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..) => {
             unreachable!()
         }
     }
 }
 
+fn encode_bytecode_trait_type(vm: &VM, trait_ty: &BytecodeTraitType, buffer: &mut ByteBuffer) {
+    buffer.emit_u32(trait_ty.trait_id.0);
+    encode_bytecode_type_array(vm, &trait_ty.type_params, buffer);
+    buffer.emit_u32(trait_ty.bindings.len() as u32);
+
+    for (alias_id, ty) in &trait_ty.bindings {
+        buffer.emit_u32(alias_id.0);
+        encode_bytecode_type(vm, ty, buffer);
+    }
+}
+
 fn encode_constpool_array(vm: &VM, fct: &BytecodeFunction, buffer: &mut ByteBuffer) {
     buffer.emit_u32(fct.const_pool_entries().len() as u32);
 

diff --git a/pkgs/boots/bytecode.dora b/pkgs/boots/bytecode.dora
@@ -1,4 +1,4 @@
-pub use package::bytecode::data::{BytecodeFunction, BytecodeRegister, BytecodeType, ConstPoolId, ConstPoolEntry, Location};
+pub use package::bytecode::data::{BytecodeFunction, BytecodeRegister, BytecodeTraitType, BytecodeType, ConstPoolId, ConstPoolEntry, Location};
 pub use package::bytecode::dump::{BytecodeDumper, dumpInstruction};
 pub use package::bytecode::program::{AliasId, AliasData, ClassId, ClassData, ClassFieldId,
     ClassField, EnumId, EnumData, EnumVariant,

diff --git a/pkgs/boots/bytecode/data.dora b/pkgs/boots/bytecode/data.dora
@@ -220,6 +220,8 @@ pub enum BytecodeType {
     TypeParam(Int32),
     Lambda(Array[BytecodeType], BytecodeType),
     TypeAlias(AliasId),
+    Assoc(AliasId, Array[BytecodeType]),
+    GenericAssoc { typeParamId: Int32, traitTy: BytecodeTraitType, assocId: AliasId },
 }
 
 impl BytecodeType {
@@ -256,7 +258,8 @@ impl BytecodeType {
             BytecodeType::Tuple(subtypes) => subtypes.isGeneric(),
             BytecodeType::TypeParam(idx) => true,
             BytecodeType::Lambda(params, ret) => params.isGeneric() || ret.isGeneric(),
-            BytecodeType::TypeAlias(alias_id) => unreachable[Bool](),
+            BytecodeType::GenericAssoc(..) => true,
+            BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..)  => unreachable[Bool](),
         }
     }
 
@@ -323,7 +326,13 @@ impl BytecodeType {
             BytecodeType::Lambda(params, ret) => {
                 BytecodeType::Lambda(params.specialize(type_params), ret.specialize(type_params))
             },
-            BytecodeType::TypeAlias(alias_id) => unreachable[BytecodeType](),
+            BytecodeType::GenericAssoc(typeParamId, ..) => {
+                let typeParamTy = type_params(typeParamId.toInt64());
+                assert(!typeParamTy.isGeneric());
+
+                unimplemented[BytecodeType]()
+            }
+            BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..) => unreachable[BytecodeType](),
         }
     }
 }
@@ -456,6 +465,8 @@ impl Equals for BytecodeType {
                     _ => false,
                 }
             }
+
+            BytecodeType::Assoc(..) | BytecodeType::GenericAssoc(..) => unreachable[Bool](),
         }
     }
 }
@@ -481,6 +492,7 @@ impl Hash for BytecodeType {
             BytecodeType::TypeParam(id) => opc::BC_TYPE_TYPE_PARAM ^ id,
             BytecodeType::Lambda(params, ret) => params.hash() ^ ret.hash(),
             BytecodeType::TypeAlias(id) => opc::BC_TYPE_TYPE_ALIAS ^ id.hash(),
+            BytecodeType::Assoc(..) | BytecodeType::GenericAssoc(..) => unreachable[Int32](),
         }
     }
 }
@@ -506,6 +518,7 @@ impl Stringable for BytecodeType {
             BytecodeType::TypeParam(idx) => "TypeParam(${idx})",
             BytecodeType::Lambda(params, ty) => "Lambda(${params}, ${ty})",
             BytecodeType::TypeAlias(id) => "TypeAlias(${id})",
+            BytecodeType::Assoc(..) | BytecodeType::GenericAssoc(..) => unreachable[String](),
         }
     }
 }
@@ -545,3 +558,9 @@ pub struct Location {
     pub line: Int32,
     pub column: Int32,
 }
+
+pub class BytecodeTraitType {
+    pub trait_id: TraitId,
+    pub typeParams: Array[BytecodeType],
+    pub bindings: Array[(AliasId, BytecodeType)],
+}
diff --git a/pkgs/boots/bytecode/opcode.dora b/pkgs/boots/bytecode/opcode.dora
@@ -83,7 +83,8 @@ pub const BC_TYPE_TRAIT_OBJECT: Int32 = 14;
 pub const BC_TYPE_LAMBDA: Int32 = 15;
 pub const BC_TYPE_TYPE_ALIAS: Int32 = 16;
 pub const BC_TYPE_ASSOC: Int32 = 17;
-pub const BC_TYPE_THIS: Int32 = 18;
+pub const BC_TYPE_GENERIC_ASSOC: Int32 = 18;
+pub const BC_TYPE_THIS: Int32 = 19;
 
 pub const CONSTPOOL_OPCODE_STRING: Int32 = 0;
 pub const CONSTPOOL_OPCODE_FLOAT32: Int32 = 1;
@@ -342,6 +343,7 @@ pub fn bytecodeTypeName(code: Int32): String {
   if code == BC_TYPE_LAMBDA { return "Lambda"; }
   if code == BC_TYPE_TYPE_ALIAS { return "TypeAlias"; }
   if code == BC_TYPE_ASSOC { return "Assoc"; }
+  if code == BC_TYPE_GENERIC_ASSOC { return "GenericAssoc"; }
   if code == BC_TYPE_THIS { return "This"; }
   unreachable[String]()
 }

diff --git a/pkgs/boots/deserializer.dora b/pkgs/boots/deserializer.dora
@@ -1,5 +1,5 @@
 use package::interface::{Address, Config, StructData, EnumData, EnumVariantData, CompilationMode};
-use package::bytecode::{AliasId, BytecodeFunction, BytecodeType, ClassId, ConstPoolEntry, EnumId, FunctionId, ClassFieldId, Location, StructId, StructFieldId, TraitId};
+use package::bytecode::{AliasId, BytecodeFunction, BytecodeTraitType, BytecodeType, ClassId, ConstPoolEntry, EnumId, FunctionId, ClassFieldId, Location, StructId, StructFieldId, TraitId};
 use package::bytecode::opcode as opc;
 use package::compilation::CompilationInfo;
 use package::interface::{FunctionInliningData, FunctionInliningInfo, Architecture};
@@ -183,12 +183,32 @@ fn decodeBytecodeType(reader: ByteReader): BytecodeType {
     } else if opcode == opc::BC_TYPE_TYPE_ALIAS {
         let alias_id = AliasId(reader.readId());
         BytecodeType::TypeAlias(alias_id)
+    } else if opcode == opc::BC_TYPE_GENERIC_ASSOC {
+        let typeParamId = reader.readId();
+        let traitTy = decodeBytecodeTraitType(reader);
+        let assocId = AliasId(reader.readId());
+        BytecodeType::GenericAssoc(typeParamId, traitTy, assocId)
     } else {
         println("unknown bytecode type opcode = ${opcode}");
         unreachable[BytecodeType]()
     }
 }
 
+fn decodeBytecodeTraitType(reader: ByteReader): BytecodeTraitType {
+    let trait_id = TraitId(reader.readId());
+    let typeParams = decodeBytecodeTypeArray(reader);
+    let length = reader.readInt32().toInt64();
+    let bindings = Vec[(AliasId, BytecodeType)]::newWithCapacity(length);
+
+    for _ in std::range(0, length) {
+        let alias_id = AliasId(reader.readId());
+        let ty = decodeBytecodeType(reader);
+        bindings.push((alias_id, ty));
+    }
+
+    BytecodeTraitType(trait_id, typeParams, bindings = bindings.toArray())
+}
+
 fn decodeConstPool(reader: ByteReader): Array[ConstPoolEntry] {
     let size = reader.readInt32().toInt64();
 

diff --git a/pkgs/boots/graph_builder.dora b/pkgs/boots/graph_builder.dora
@@ -1837,7 +1837,9 @@ impl SsaGen {
             }
             BytecodeType::This
             | BytecodeType::TypeParam(_)
-            | BytecodeType::TypeAlias(_) => unreachable[()](),
+            | BytecodeType::TypeAlias(_)
+            | BytecodeType::Assoc(..)
+            | BytecodeType::GenericAssoc(..) => unreachable[()](),
         }
     }
 
@@ -2716,7 +2718,7 @@ impl SsaGen {
             | BytecodeType::Tuple(_) => Type::Address,
             BytecodeType::This
             | BytecodeType::TypeParam(_) => unreachable[Type](),
-            BytecodeType::TypeAlias(_) => unreachable[Type](),
+            BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..) | BytecodeType::GenericAssoc(..) => unreachable[Type](),
         }
     }
 

diff --git a/pkgs/boots/location.dora b/pkgs/boots/location.dora
@@ -503,7 +503,9 @@ fn computeArgumentLocations(codegen: CodeGen, ci: CompilationInfo): ArgumentLoca
             BytecodeType::Unit
             | BytecodeType::This
             | BytecodeType::TypeParam(_)
-            | BytecodeType::TypeAlias(_) => unreachable[Bool](),
+            | BytecodeType::TypeAlias(_)
+            | BytecodeType::Assoc(..)
+            | BytecodeType::GenericAssoc(..) => unreachable[Bool](),
         };
 
         if uses_fp_reg {

diff --git a/pkgs/boots/regalloc.dora b/pkgs/boots/regalloc.dora
@@ -1133,6 +1133,8 @@ pub fn isReference(ty: BytecodeType): Bool {
                 EnumLayout::PtrOrNull(_) | EnumLayout::Tagged => true,
             }
         }
-        BytecodeType::TypeAlias(_) => unreachable[Bool](),
+        BytecodeType::TypeAlias(_)
+        | BytecodeType::Assoc(..)
+        | BytecodeType::GenericAssoc(..) => unreachable[Bool](),
     }
 }
diff --git a/pkgs/boots/serializer.dora b/pkgs/boots/serializer.dora
@@ -215,7 +215,7 @@ pub fn encodeBytecodeType(writer: ByteWriter, ty: BytecodeType) {
             encodeBytecodeTypeArray(writer, params);
             encodeBytecodeType(writer, ret);
         },
-        BytecodeType::TypeAlias(id) => {
+        BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..) | BytecodeType::GenericAssoc(..) => {
             unimplemented[()]();
         }
     }