implement Select and HasAttr

fix-codegen/src/disassembler.rs

@@ -320,6 +320,27 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
                 let span_id = self.read_u32();
                 ("SelectDynamic", format!("span={}", span_id))
             }
+            Op::HasAttrPathStatic => {
+                let span_id = self.read_u32();
+                let key_id = self.read_u32();
+                (
+                    "HasAttrPathStatic",
+                    format!("key={} span={}", self.ctx.resolve_string(key_id), span_id),
+                )
+            }
+            Op::HasAttrPathDynamic => {
+                let span_id = self.read_u32();
+                ("HasAttrPathDynamic", format!("span={}", span_id))
+            }
+            Op::HasAttrStatic => {
+                let key_id = self.read_u32();
+                (
+                    "HasAttrStatic",
+                    format!("key={}", self.ctx.resolve_string(key_id)),
+                )
+            }
+            Op::HasAttrDynamic => ("HasAttrDynamic", String::new()),
+            Op::HasAttrResolve => ("HasAttrResolve", String::new()),
             Op::JumpIfSelectSucceeded => {
                 let offset = self.read_i32();
                 let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
@@ -328,9 +349,13 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
                     format!("-> {:04x} offset={}", target, offset),
                 )
             }
-            Op::HasAttr => {
-                let path_len = self.read_u16();
-                ("HasAttr", format!("path_len={}", path_len))
+            Op::JumpIfSelectFailed => {
+                let offset = self.read_i32();
+                let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
+                (
+                    "JumpIfSelectFailed",
+                    format!("-> {:04x} offset={}", target, offset),
+                )
             }
 
             Op::MakeList => {

fix-codegen/src/lib.rs

@@ -47,8 +47,13 @@ pub enum Op {
     MakeEmptyAttrs,
     SelectStatic,
     SelectDynamic,
+    HasAttrPathStatic,
+    HasAttrPathDynamic,
+    HasAttrStatic,
+    HasAttrDynamic,
+    HasAttrResolve,
     JumpIfSelectSucceeded,
-    HasAttr,
+    JumpIfSelectFailed,
 
     MakeList,
     MakeEmptyList,
@@ -822,6 +827,7 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
     ) {
         self.emit_expr(expr);
 
+        let mut dynamic_patches = Vec::new();
         for attr in attrpath.iter() {
             match *attr {
                 Attr::Str(sym, _) => {
@@ -831,6 +837,8 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
                     self.emit_str_id(sym);
                 }
                 Attr::Dynamic(key_expr, _) => {
+                    self.emit_op(Op::JumpIfSelectFailed);
+                    dynamic_patches.push(self.emit_i32_placeholder());
                     self.emit_expr(key_expr);
                     let span_id = self.ctx.register_span(span);
                     self.emit_op(Op::SelectDynamic);
@@ -840,35 +848,65 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
         }
 
         if let Some(default) = default {
+            let before: i32 = self.ctx.get_code().len().try_into().unwrap();
+            for patch in dynamic_patches {
+                self.patch_jump_target(patch);
+            }
             self.emit_op(Op::JumpIfSelectSucceeded);
             let placeholder = self.emit_i32_placeholder();
-            let before: i32 = self.ctx.get_code().len().try_into().unwrap();
             self.emit_expr(default);
             let after: i32 = self.ctx.get_code().len().try_into().unwrap();
-            self.patch_i32(placeholder, after - before);
+            // Offset is relative to after the placeholder, so subtract the
+            // size of JumpIfSelectSucceeded (1) + placeholder (4).
+            self.patch_i32(placeholder, after - before - 5);
+        } else {
+            for patch in dynamic_patches {
+                self.patch_jump_target(patch);
+            }
         }
     }
 
     fn emit_has_attr(&mut self, lhs: RawIrRef<'_>, rhs: &[Attr<RawIrRef<'_>>]) {
         self.emit_expr(lhs);
-        for attr in rhs.iter() {
-            if let Attr::Dynamic(expr, _) = *attr {
-                self.emit_expr(expr);
-            }
-        }
-        self.emit_op(Op::HasAttr);
-        self.emit_u16(rhs.len() as u16);
-        for attr in rhs.iter() {
+
+        let mut dynamic_patches = Vec::new();
+        let [attrs @ .., last] = rhs else {
+            panic!("attrpath is empty");
+        };
+        for attr in attrs {
             match *attr {
-                Attr::Str(sym, _) => {
-                    self.emit_u8(AttrKeyType::Static as u8);
+                Attr::Str(sym, span) => {
+                    let span_id = self.ctx.register_span(span);
+                    self.emit_op(Op::HasAttrPathStatic);
+                    self.emit_u32(span_id);
                     self.emit_str_id(sym);
                 }
-                Attr::Dynamic(_, _) => {
-                    self.emit_u8(AttrKeyType::Dynamic as u8);
+                Attr::Dynamic(key_expr, span) => {
+                    self.emit_op(Op::JumpIfSelectFailed);
+                    dynamic_patches.push(self.emit_i32_placeholder());
+                    self.emit_expr(key_expr);
+                    let span_id = self.ctx.register_span(span);
+                    self.emit_op(Op::HasAttrPathDynamic);
+                    self.emit_u32(span_id);
                 }
             }
         }
+        match *last {
+            Attr::Str(sym, _) => {
+                self.emit_op(Op::HasAttrStatic);
+                self.emit_str_id(sym);
+            }
+            Attr::Dynamic(key_expr, _) => {
+                self.emit_op(Op::JumpIfSelectFailed);
+                dynamic_patches.push(self.emit_i32_placeholder());
+                self.emit_expr(key_expr);
+                self.emit_op(Op::HasAttrDynamic);
+            }
+        }
+        for patch in dynamic_patches {
+            self.patch_jump_target(patch);
+        }
+        self.emit_op(Op::HasAttrResolve);
     }
 
     fn emit_with(