fix disassembler

fix-codegen/src/disassembler.rs

@@ -3,7 +3,7 @@ use std::fmt::Write;
 use colored::Colorize;
 use num_enum::TryFromPrimitive;
 
-use crate::{InstructionPtr, Op};
+use crate::{AttrKeyType, InstructionPtr, OperandType, Op};
 
 pub trait DisassemblerContext {
     fn resolve_string(&self, id: u32) -> &str;
@@ -71,6 +71,24 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
         f64::from_le_bytes(bytes)
     }
 
+    fn read_operand_data(&mut self) {
+        let tag = self.read_u8();
+        let ty = OperandType::try_from_primitive(tag).expect("invalid operand type");
+        match ty {
+            OperandType::Const => {
+                self.read_u32();
+            }
+            OperandType::Local => {
+                self.read_u8();
+                self.read_u32();
+            }
+            OperandType::Builtins => {}
+            OperandType::BigInt => {
+                self.read_i64();
+            }
+        }
+    }
+
     pub fn disassemble(&mut self) -> String {
         self.disassemble_impl(false)
     }
@@ -259,7 +277,26 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
 
             Op::MakeAttrs => {
                 let count = self.read_u32();
-                ("MakeAttrs", format!("size={}", count))
+                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();
+                        }
+                    }
+                    self.read_operand_data();
+                    let _span_id = self.read_u32();
+                    args.push(']');
+                }
+                ("MakeAttrs", args)
             }
             Op::MakeEmptyAttrs => ("MakeEmptyAttrs", String::new()),
 
@@ -290,6 +327,9 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
 
             Op::MakeList => {
                 let count = self.read_u32();
+                for _ in 0..count {
+                    self.read_operand_data();
+                }
                 ("MakeList", format!("size={}", count))
             }
             Op::MakeEmptyList => ("MakeEmptyList", String::new()),

fix/src/main.rs

@@ -87,7 +87,7 @@ fn run_repl(eval: &mut Evaluator) -> Result<()> {
     let mut scope = HashSet::new();
     const RE: ere::Regex<3> = ere::compile_regex!("^[ \t]*([a-zA-Z_][a-zA-Z0-9_'-]*)[ \t]*(.*)$");
     loop {
-        let readline = rl.readline("nix-js-repl> ");
+        let readline = rl.readline("fix-repl> ");
         match readline {
             Ok(line) => {
                 if line.trim().is_empty() {