implement dynamic key; implement __curPos; other small changes

fix-codegen/src/disassembler.rs

@@ -1,9 +1,10 @@
 use std::fmt::Write;
 
 use colored::Colorize;
+use fix_builtins::BuiltinId;
 use num_enum::TryFromPrimitive;
 
-use crate::{AttrKeyType, InstructionPtr, Op, OperandType};
+use crate::{InstructionPtr, Op, OperandType};
 
 pub trait DisassemblerContext {
     fn resolve_string(&self, id: u32) -> &str;
@@ -292,31 +293,30 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
                 ("Call", "arg=?".into())
             },
             Op::DispatchPrimOp => {
-                todo!();
+                let id = BuiltinId::try_from_primitive(self.read_u8()).expect("invalid builtin id");
+                ("DispatchPrimOp", format!("id={id:?}"))
             }
 
             Op::MakeAttrs => {
-                let count = self.read_u32();
-                let mut args = format!("size={}", count);
-                for _ in 0..count {
-                    let key_tag = self.read_u8();
-                    let key_ty =
-                        AttrKeyType::try_from_primitive(key_tag).expect("invalid attr key type");
-                    match key_ty {
-                        AttrKeyType::Static => {
-                            let key_id = self.read_u32();
-                            let _ =
-                                write!(args, " [{}={}", self.ctx.resolve_string(key_id), key_id);
-                        }
-                        AttrKeyType::Dynamic => {
-                            let _ = write!(args, " [dyn");
-                            self.read_operand_data();
-                        }
-                    }
+                let static_count = self.read_u32();
+                let dynamic_count = self.read_u32();
+                let mut args = format!("static={} dynamic={}", static_count, dynamic_count);
+
+                for _ in 0..static_count {
+                    let key_id = self.read_u32();
+                    let _ = write!(args, " [{}={}", self.ctx.resolve_string(key_id), key_id);
                     self.read_operand_data();
                     let _span_id = self.read_u32();
                     args.push(']');
                 }
+
+                for _ in 0..dynamic_count {
+                    let _ = write!(args, " [dyn");
+                    self.read_operand_data();
+                    let _span_id = self.read_u32();
+                    args.push(']');
+                }
+
                 ("MakeAttrs", args)
             }
             Op::MakeEmptyAttrs => ("MakeEmptyAttrs", String::new()),
@@ -442,10 +442,6 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
                 let id = self.read_u8();
                 ("LoadBuiltin", format!("id={}", id))
             }
-            Op::MkPos => {
-                let span_id = self.read_u32();
-                ("MkPos", format!("id={}", span_id))
-            }
             Op::LoadReplBinding => {
                 let idx = self.read_u32();
                 let name = self.ctx.resolve_string(idx);

fix-codegen/src/lib.rs

@@ -90,8 +90,6 @@ pub enum Op {
     LoadBuiltins,
     LoadBuiltin,
 
-    MkPos,
-
     LoadReplBinding,
     LoadScopedBinding,
 
@@ -646,11 +644,6 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
                 self.emit_str_id(raw_idx);
                 self.emit_u32(span_id);
             }
-            &Ir::CurPos(span) => {
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::MkPos);
-                self.emit_u32(span_id);
-            }
             &Ir::ReplBinding(name) => {
                 self.emit_op(Op::LoadReplBinding);
                 self.emit_str_id(name);
@@ -879,19 +872,22 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
             return;
         }
 
-        let total = stcs.len() + dyns.len();
+        for &(key_expr, _val, _span) in dyns.iter() {
+            self.emit_expr(key_expr);
+        }
+
         self.emit_op(Op::MakeAttrs);
-        self.emit_u32(total as u32);
+        self.emit_u32(stcs.len() as u32);
+        self.emit_u32(dyns.len() as u32);
 
         for (&sym, &(val, span)) in stcs.iter() {
-            self.emit_u8(AttrKeyType::Static as u8);
             self.emit_str_id(sym);
             self.emit_maybe_thunk(val);
             let span_id = self.ctx.register_span(span);
             self.emit_u32(span_id);
         }
+
         for &(_key, val, span) in dyns.iter() {
-            self.emit_u8(AttrKeyType::Dynamic as u8);
             self.emit_maybe_thunk(val);
             let span_id = self.ctx.register_span(span);
             self.emit_u32(span_id);