split SelectDefault -> SelectStatic & Jump...

fix-codegen/src/disassembler.rs

@@ -255,9 +255,7 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
                 ("MakePatternClosure", arg_str)
             }
 
-            Op::Call => {
-                ("Call", String::new())
-            },
+            Op::Call => ("Call", String::new()),
 
             Op::MakeAttrs => {
                 let count = self.read_u32();
@@ -265,17 +263,24 @@ impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
             }
             Op::MakeEmptyAttrs => ("MakeEmptyAttrs", String::new()),
 
-            Op::Select => {
-                let path_len = self.read_u16();
-                let span_id = self.read_u32();
-                ("Select", format!("path_len={} span={}", path_len, span_id))
-            }
-            Op::SelectDefault => {
-                let path_len = self.read_u16();
+            Op::SelectStatic => {
                 let span_id = self.read_u32();
+                let key_id = self.read_u32();
                 (
-                    "SelectDefault",
-                    format!("path_len={} span={}", path_len, span_id),
+                    "SelectStatic",
+                    format!("key={} span={}", self.ctx.resolve_string(key_id), span_id),
+                )
+            }
+            Op::SelectDynamic => {
+                let span_id = self.read_u32();
+                ("SelectDynamic", format!("span={}", span_id))
+            }
+            Op::JumpIfSelectSucceeded => {
+                let offset = self.read_i32();
+                let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
+                (
+                    "JumpIfSelectSucceeded",
+                    format!("-> {:04x} offset={}", target, offset),
                 )
             }
             Op::HasAttr => {

fix-codegen/src/lib.rs

@@ -45,8 +45,9 @@ pub enum Op {
 
     MakeAttrs,
     MakeEmptyAttrs,
-    Select,
-    SelectDefault,
+    SelectStatic,
+    SelectDynamic,
+    JumpIfSelectSucceeded,
     HasAttr,
 
     MakeList,
@@ -114,13 +115,6 @@ pub enum OperandType {
     BigInt,
 }
 
-#[repr(u8)]
-#[derive(Debug, Clone, Copy, TryFromPrimitive)]
-pub enum AttrKeyType {
-    Static,
-    Dynamic,
-}
-
 pub enum Const {
     Smi(i32),
     Float(f64),
@@ -130,6 +124,13 @@ pub enum Const {
     Null,
 }
 
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, TryFromPrimitive)]
+pub enum AttrKeyType {
+    Static,
+    Dynamic,
+}
+
 pub enum InlineOperand {
     Const(Const),
     Local { layer: u16, local: u32 },
@@ -626,6 +627,7 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
                 self.emit_with(namespace, body, thunks);
             }
             &Ir::WithLookup(name) => {
+                // TODO: specialize shallow with lookups
                 self.emit_op(Op::PrepareWith);
                 self.emit_op(Op::LookupWith);
                 self.emit_str_id(name);
@@ -819,34 +821,32 @@ impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
         span: TextRange,
     ) {
         self.emit_expr(expr);
-        for attr in attrpath.iter() {
-            if let Attr::Dynamic(expr, _) = *attr {
-                self.emit_expr(expr);
-            }
-        }
-        if let Some(default) = default {
-            self.emit_expr(default);
-            let span_id = self.ctx.register_span(span);
-            self.emit_op(Op::SelectDefault);
-            self.emit_u16(attrpath.len() as u16);
-            self.emit_u32(span_id);
-        } else {
-            let span_id = self.ctx.register_span(span);
-            self.emit_op(Op::Select);
-            self.emit_u16(attrpath.len() as u16);
-            self.emit_u32(span_id);
-        }
+
         for attr in attrpath.iter() {
             match *attr {
                 Attr::Str(sym, _) => {
-                    self.emit_u8(AttrKeyType::Static as u8);
+                    let span_id = self.ctx.register_span(span);
+                    self.emit_op(Op::SelectStatic);
+                    self.emit_u32(span_id);
                     self.emit_str_id(sym);
                 }
-                Attr::Dynamic(_, _) => {
-                    self.emit_u8(AttrKeyType::Dynamic as u8);
+                Attr::Dynamic(key_expr, _) => {
+                    self.emit_expr(key_expr);
+                    let span_id = self.ctx.register_span(span);
+                    self.emit_op(Op::SelectDynamic);
+                    self.emit_u32(span_id);
                 }
             }
         }
+
+        if let Some(default) = default {
+            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);
+        }
     }
 
     fn emit_has_attr(&mut self, lhs: RawIrRef<'_>, rhs: &[Attr<RawIrRef<'_>>]) {