Remove BindMethod opcode. It is really just BuildFunction+WriteAttribute

Author: egranata

compiler-lib/src/bc_reader.rs

@@ -278,21 +278,6 @@ impl BytecodeReader {
             haxby_opcodes::OPCODE_BUILD_STRUCT => Ok(Opcode::BuildStruct),
             haxby_opcodes::OPCODE_BUILD_ENUM => Ok(Opcode::BuildEnum),
             haxby_opcodes::OPCODE_BUILD_MIXIN => Ok(Opcode::BuildMixin),
-            haxby_opcodes::OPCODE_BIND_METHOD => {
-                let b0 = match self.read_u8() {
-                    Ok(b) => b,
-                    Err(_) => {
-                        return Err(DecodeError::InsufficientData);
-                    }
-                };
-                let w1 = match self.read_u16() {
-                    Ok(w) => w,
-                    Err(_) => {
-                        return Err(DecodeError::InsufficientData);
-                    }
-                };
-                Ok(Opcode::BindMethod(b0, w1))
-            }
             haxby_opcodes::OPCODE_BIND_CASE => {
                 let b0 = match self.read_u8() {
                     Ok(b) => b,

compiler-lib/src/bc_writer.rs

@@ -124,10 +124,6 @@ impl BytecodeWriter {
             Opcode::BuildStruct => self.write_u8(haxby_opcodes::OPCODE_BUILD_STRUCT),
             Opcode::BuildMixin => self.write_u8(haxby_opcodes::OPCODE_BUILD_MIXIN),
             Opcode::BuildEnum => self.write_u8(haxby_opcodes::OPCODE_BUILD_ENUM),
-            Opcode::BindMethod(a, n) => self
-                .write_u8(haxby_opcodes::OPCODE_BIND_METHOD)
-                .write_u8(*a)
-                .write_u16(*n),
             Opcode::BindCase(a, n) => self
                 .write_u8(haxby_opcodes::OPCODE_BIND_CASE)
                 .write_u8(*a)

compiler-lib/src/builder/compiler_opcodes.rs

@@ -66,7 +66,6 @@ pub enum CompilerOpcode {
     BuildStruct,
     BuildEnum,
     BuildMixin,
-    BindMethod(u8, u16),
     BindCase(u8, u16),
     IncludeMixin,
     NewEnumVal(bool, u16),
@@ -142,7 +141,6 @@ impl CompilerOpcode {
             Self::BuildStruct => false,
             Self::BuildEnum => false,
             Self::BuildMixin => false,
-            Self::BindMethod(..) => false,
             Self::BindCase(..) => false,
             Self::IncludeMixin => false,
             Self::NewEnumVal(..) => false,
@@ -254,7 +252,6 @@ impl CompilerOpcode {
             Self::BuildStruct => VmOpcode::BuildStruct,
             Self::BuildEnum => VmOpcode::BuildEnum,
             Self::BuildMixin => VmOpcode::BuildMixin,
-            Self::BindMethod(x, y) => VmOpcode::BindMethod(*x, *y),
             Self::BindCase(x, y) => VmOpcode::BindCase(*x, *y),
             Self::IncludeMixin => VmOpcode::IncludeMixin,
             Self::NewEnumVal(v, n) => {
@@ -337,7 +334,6 @@ impl std::fmt::Display for CompilerOpcode {
             BuildStruct => write!(f, "BuildStruct"),
             BuildEnum => write!(f, "BuildEnum"),
             BuildMixin => write!(f, "BuildMixin"),
-            BindMethod(x, y) => write!(f, "BindMethod({}, {})", x, y),
             BindCase(x, y) => write!(f, "BindCase({}, {})", x, y),
             IncludeMixin => write!(f, "IncludeMixin"),
             NewEnumVal(has_payload, n) => write!(f, "NewEnumVal({}, {})", has_payload, n),

compiler-lib/src/do_compile/mod.rs

@@ -339,7 +339,7 @@ fn emit_method_decl_compile(md: &MethodDecl, params: &mut CompileParams) -> Comp
         .writer
         .get_current_block()
         .write_opcode_and_source_info(
-            CompilerOpcode::BindMethod(
+            CompilerOpcode::BuildFunction(
                 if md.args.vararg {
                     FUNC_ACCEPTS_VARARG
                 } else {
@@ -350,10 +350,10 @@ fn emit_method_decl_compile(md: &MethodDecl, params: &mut CompileParams) -> Comp
                     } else {
                         0
                     },
-                name_idx,
             ),
             md.loc.clone(),
-        );
+        )
+        .write_opcode_and_source_info(CompilerOpcode::WriteAttribute(name_idx), md.loc.clone());
 
     Ok(())
 }

compiler-lib/src/dump/opcodes.rs

@@ -70,16 +70,6 @@ pub fn opcode_prettyprint(
                 << symbol_best_repr(resolver, idx)
                 << "]"
         }
-        Opcode::BindMethod(arg, idx) => {
-            buffer
-                << "BIND_METHOD("
-                << arg
-                << ",@"
-                << idx
-                << ") ["
-                << const_best_repr(resolver, idx)
-                << "]"
-        }
         Opcode::BindCase(arg, idx) => {
             buffer
                 << "BIND_CASE("

opcodes-lib/src/lib.rs

@@ -63,7 +63,6 @@ pub const OPCODE_STORE_UPLEVEL: u8 = 82;
 pub const OPCODE_BUILD_STRUCT: u8 = 83;
 pub const OPCODE_BUILD_ENUM: u8 = 84;
 pub const OPCODE_BUILD_MIXIN: u8 = 85;
-pub const OPCODE_BIND_METHOD: u8 = 86;
 pub const OPCODE_BIND_CASE: u8 = 87;
 pub const OPCODE_INCLUDE_MIXIN: u8 = 88;
 pub const OPCODE_NEW_ENUM_VAL: u8 = 89;
@@ -267,7 +266,6 @@ pub enum Opcode {
     BuildStruct,
     BuildEnum,
     BuildMixin,
-    BindMethod(u8, u16),
     BindCase(u8, u16),
     IncludeMixin,
     NewEnumVal(u8, u16),
@@ -345,7 +343,6 @@ impl std::fmt::Display for Opcode {
             Self::BuildStruct => write!(f, "BUILD_STRUCT"),
             Self::BuildEnum => write!(f, "BUILD_ENUM"),
             Self::BuildMixin => write!(f, "BUILD_MIXIN"),
-            Self::BindMethod(arg0, arg1) => write!(f, "BIND_M {arg0} @{arg1}"),
             Self::BindCase(arg0, arg1) => write!(f, "BIND_C {arg0} @{arg1}"),
             Self::IncludeMixin => write!(f, "INCLUDE_MIXIN"),
             Self::NewEnumVal(arg0, arg1) => write!(f, "NEW_ENUM_VAL {arg0} @{arg1}"),

vm-lib/src/builtins/runtime_error.rs

@@ -16,7 +16,7 @@ pub(super) fn insert_runtime_error_builtins(builtins: &mut VmGlobals) {
     let int = builtins.get_builtin_type_by_id(BuiltinTypeId::Int);
     let str = builtins.get_builtin_type_by_id(BuiltinTypeId::String);
 
-    let rt_err_enum = Enum::new_with_cases(
+    let rt_err_enum = RuntimeValue::Type(RuntimeValueType::Enum(Enum::new_with_cases(
         "RuntimeError",
         &[
             EnumCase {
@@ -54,15 +54,18 @@ pub(super) fn insert_runtime_error_builtins(builtins: &mut VmGlobals) {
                 payload_type: None,
             },
         ],
-    );
+    )));
 
-    rt_err_enum.store_named_value(
+    let _ = rt_err_enum.write_attribute(
         "ArgcMismatch",
         RuntimeValue::Type(RuntimeValueType::Struct(argc_mismatch)),
     );
 
     builtins.register_builtin_type(
         haxby_opcodes::BuiltinTypeId::RuntimeError,
-        RuntimeValueType::Enum(rt_err_enum),
+        rt_err_enum
+            .as_type()
+            .expect("RuntimeError is a type")
+            .clone(),
     );
 }

vm-lib/src/runtime_value/enumeration.rs

@@ -133,10 +133,6 @@ impl Enum {
         self.imp.load_named_value(name)
     }
 
-    pub(crate) fn store_named_value(&self, name: &str, val: RuntimeValue) {
-        self.imp.store_named_value(name, val);
-    }
-
     pub fn include_mixin(&self, mixin: &Mixin) {
         self.imp.include_mixin(mixin);
     }
@@ -174,7 +170,8 @@ impl Enum {
     {
         let t = T::default();
         let name = t.name().to_owned();
-        self.store_named_value(&name, RuntimeValue::Function(Function::builtin_from(t)));
+        self.imp
+            .store_named_value(&name, RuntimeValue::Function(Function::builtin_from(t)));
     }
 }
 

vm-lib/src/runtime_value/mixin.rs

@@ -30,10 +30,6 @@ impl MixinImpl {
         }
     }
 
-    fn store_named_value(&self, name: &str, val: RuntimeValue) {
-        self.entries.write(name, val);
-    }
-
     fn named_values(&self) -> Vec<String> {
         self.entries.keys().into_iter().collect()
     }
@@ -73,10 +69,6 @@ impl Mixin {
         self.imp.load_named_value(name)
     }
 
-    pub(crate) fn store_named_value(&self, name: &str, val: RuntimeValue) {
-        self.imp.store_named_value(name, val);
-    }
-
     pub fn named_values(&self) -> Vec<String> {
         self.imp.named_values()
     }

vm-lib/src/runtime_value/structure.rs

@@ -73,10 +73,6 @@ impl Struct {
         self.imp.load_named_value(name)
     }
 
-    pub(crate) fn store_named_value(&self, name: &str, val: RuntimeValue) {
-        self.imp.store_named_value(name, val);
-    }
-
     pub fn include_mixin(&self, mixin: &Mixin) {
         self.imp.include_mixin(mixin);
     }
@@ -104,7 +100,8 @@ impl Struct {
     {
         let t = T::default();
         let name = t.name().to_owned();
-        self.store_named_value(&name, RuntimeValue::Function(Function::builtin_from(t)));
+        self.imp
+            .store_named_value(&name, RuntimeValue::Function(Function::builtin_from(t)));
     }
 
     pub fn extract_field<FnType, OkType>(