fix(compiler-rs): move context.slots to block.slots for nested slots

Author: zhiyuanzmj

packages/compiler-rs/src/ir/index.rs

@@ -70,6 +70,7 @@ pub struct BlockIRNode<'a> {
   pub effect: Vec<IREffect<'a>>,
   pub operation: Vec<OperationNode<'a>>,
   pub returns: Vec<i32>,
+  pub slots: Vec<IRSlots<'a>>,
   pub props: Option<SimpleExpressionNode<'a>>,
 }
 impl<'a> BlockIRNode<'a> {
@@ -80,6 +81,7 @@ impl<'a> BlockIRNode<'a> {
       effect: Vec::new(),
       operation: Vec::new(),
       returns: Vec::new(),
+      slots: Vec::new(),
       props: None,
     }
   }

packages/compiler-rs/src/transform.rs

@@ -31,12 +31,9 @@ use crate::compile::Template;
 use crate::generate::CodegenContext;
 use crate::traverse::jsx::JsxTraverse;
 use crate::{
-  ir::{
-    component::IRSlots,
-    index::{
-      BlockIRNode, DynamicFlag, IRDynamicInfo, IREffect, Modifiers, OperationNode, RootIRNode,
-      RootNode, SimpleExpressionNode,
-    },
+  ir::index::{
+    BlockIRNode, DynamicFlag, IRDynamicInfo, IREffect, Modifiers, OperationNode, RootIRNode,
+    RootNode, SimpleExpressionNode,
   },
   transform::{
     transform_children::transform_children, transform_element::transform_element,
@@ -125,8 +122,6 @@ pub struct TransformContext<'a> {
   pub in_v_once: RefCell<bool>,
   pub in_v_for: RefCell<i32>,
 
-  pub slots: RefCell<Vec<IRSlots<'a>>>,
-
   pub seen: Rc<RefCell<HashSet<u32>>>,
 
   global_id: RefCell<i32>,
@@ -146,7 +141,6 @@ impl<'a> TransformContext<'a> {
       children_template: RefCell::new(Vec::new()),
       in_v_once: RefCell::new(false),
       in_v_for: RefCell::new(0),
-      slots: RefCell::new(Vec::new()),
       seen: Rc::new(RefCell::new(HashSet::new())),
       global_id: RefCell::new(0),
       node: RefCell::new(Either::A(RootNode::new(allocator))),
@@ -164,7 +158,6 @@ impl<'a> TransformContext<'a> {
     *self.block.borrow_mut() = mem::take(&mut ir.block);
     *self.ir.borrow_mut() = ir;
     *self.index.borrow_mut() = 0;
-    *self.slots.borrow_mut() = vec![];
     *self.template.borrow_mut() = String::new();
     *self.children_template.borrow_mut() = vec![];
     *self.in_v_once.borrow_mut() = false;
@@ -280,18 +273,12 @@ impl<'a> TransformContext<'a> {
     context_block: &'a mut BlockIRNode<'a>,
     ir: BlockIRNode<'a>,
     is_v_for: bool,
-    exclude_slots: bool,
   ) -> Box<dyn FnOnce() -> BlockIRNode<'a> + 'a> {
     let block = mem::take(&mut *context_block);
     let template = mem::take(&mut *self.template.borrow_mut());
     let children_template = mem::take(&mut *self.children_template.borrow_mut());
-    let mut slots = None;
 
     *context_block = ir;
-    if !exclude_slots {
-      slots = Some(mem::take(&mut *self.slots.borrow_mut()));
-    }
-
     if is_v_for {
       *self.in_v_for.borrow_mut() += 1;
     }
@@ -303,9 +290,6 @@ impl<'a> TransformContext<'a> {
       *context_block = block;
       *self.template.borrow_mut() = template;
       *self.children_template.borrow_mut() = children_template;
-      if !exclude_slots && let Some(slots) = slots {
-        *self.slots.borrow_mut() = slots;
-      }
       if is_v_for {
         *self.in_v_for.borrow_mut() -= 1;
       }
@@ -363,7 +347,6 @@ impl<'a> TransformContext<'a> {
       unsafe { &mut *_context_block },
       block,
       is_v_for.unwrap_or(false),
-      false,
     );
     self.reference(&mut context_block.dynamic);
     exit_block

packages/compiler-rs/src/transform/transform_element.rs

@@ -1,4 +1,4 @@
-use std::{cell::RefCell, rc::Rc};
+use std::{cell::RefCell, mem, rc::Rc};
 
 use napi::{
   Either,
@@ -239,7 +239,7 @@ pub fn transform_component_element<'a>(
     },
     asset,
     root: single_root && *context.in_v_for.borrow() == 0,
-    slots: context.slots.take(),
+    slots: mem::take(&mut context_block.slots),
     once: *context.in_v_once.borrow(),
     parent: None,
     anchor: None,

packages/compiler-rs/src/transform/v_slot.rs

@@ -1,3 +1,5 @@
+use std::mem;
+
 use indexmap::IndexMap;
 use napi::{Either, bindgen_prelude::Either4};
 use oxc_ast::ast::{JSXChild, JSXElement};
@@ -84,10 +86,11 @@ fn transform_component_slot<'a>(
     })
     .count();
 
-  let exit_block = create_slot_block(exp, context, context_block, false);
+  let context_block = context_block as *mut BlockIRNode;
+  let exit_block = create_slot_block(exp, context, unsafe { &mut *context_block });
 
   Box::new(move || {
-    let mut slots = context.slots.take();
+    let mut slots = mem::take(&mut unsafe { &mut *context_block }.slots);
 
     let block = exit_block();
     let has_other_slots = !slots.is_empty();
@@ -105,10 +108,10 @@ fn transform_component_slot<'a>(
         );
       } else {
         register_slot(&mut slots, arg, block);
-        *context.slots.borrow_mut() = slots;
+        unsafe { &mut *context_block }.slots = slots;
       }
     } else if has_other_slots {
-      *context.slots.borrow_mut() = slots
+      unsafe { &mut *context_block }.slots = slots
     }
   })
 }
@@ -120,11 +123,12 @@ fn transform_template_slot<'a>(
   context: &'a TransformContext<'a>,
   context_block: &'a mut BlockIRNode<'a>,
 ) -> Box<dyn FnOnce() + 'a> {
+  let _context_block = context_block as *mut BlockIRNode;
   let dynamic = &mut context_block.dynamic;
   dynamic.flags |= DynamicFlag::NonTemplate as i32;
 
   let DirectiveNode { arg, exp, .. } = dir;
-  let exit_block = create_slot_block(exp, context, context_block, true);
+  let exit_block = create_slot_block(exp, context, context_block);
 
   let v_for = find_prop_mut(unsafe { &mut *node }, Either::A(String::from("v-for")));
   let for_parse_result = if let Some(v_for) = v_for {
@@ -141,7 +145,7 @@ fn transform_template_slot<'a>(
   let v_else_dir = v_else.map(|v_else| resolve_directive(v_else, context));
 
   Box::new(move || {
-    let slots = &mut context.slots.borrow_mut();
+    let slots = &mut unsafe { &mut *_context_block }.slots;
     let block = exit_block();
     if v_if_dir.is_none() && v_else_dir.is_none() && for_parse_result.is_none() {
       let slot_name = if let Some(arg) = &arg {
@@ -268,10 +272,9 @@ fn create_slot_block<'a>(
   props: Option<SimpleExpressionNode<'a>>,
   context: &'a TransformContext<'a>,
   context_block: &'a mut BlockIRNode<'a>,
-  exclude_slots: bool,
 ) -> Box<dyn FnOnce() -> BlockIRNode<'a> + 'a> {
   let mut block = BlockIRNode::new();
   block.props = props;
 
-  (context.enter_block(context_block, block, false, exclude_slots)) as _
+  (context.enter_block(context_block, block, false)) as _
 }

packages/compiler-rs/src/transform/v_slots.rs

@@ -17,7 +17,7 @@ use crate::{
 pub unsafe fn transform_v_slots<'a>(
   context_node: *mut ContextNode<'a>,
   context: &'a TransformContext<'a>,
-  _: &'a mut BlockIRNode<'a>,
+  context_block: &'a mut BlockIRNode<'a>,
   _: &'a mut ContextNode<'a>,
 ) -> Option<Box<dyn FnOnce() + 'a>> {
   let Either::B(JSXChild::Element(node)) = (unsafe { &mut *context_node }) else {
@@ -41,7 +41,7 @@ pub unsafe fn transform_v_slots<'a>(
       let slots =
         SimpleExpressionNode::new(Either3::A(value.expression.to_expression_mut()), context);
       Some(Box::new(move || {
-        *context.slots.borrow_mut() = vec![Either4::D(IRSlotsExpression {
+        context_block.slots = vec![Either4::D(IRSlotsExpression {
           slot_type: IRSlotType::EXPRESSION,
           slots,
         })];

packages/compiler-rs/tests/snapshots/v_slot__on_component_named_slot_multiple.snap

@@ -0,0 +1,23 @@
+---
+source: tests/v_slot.rs
+expression: code
+---
+import { createComponent as _createComponent } from "vue-jsx-vapor";
+import { template as _template } from "vue";
+const t0 = _template("foo");
+(() => {
+  const n10 = _createComponent(Comp, null, {
+    left: () => {
+      const n1 = t0();
+      return n1;
+    },
+    right: () => {
+      const n6 = _createComponent(Comp, null, { left: () => {
+        const n5 = t0();
+        return n5;
+      } });
+      return n6;
+    }
+  }, true);
+  return n10;
+})();

packages/compiler-rs/tests/v_slot.rs

@@ -34,6 +34,23 @@ fn on_component_named_slot() {
   assert!(code.contains("{ foo: _slotProps0.foo }"));
 }
 
+#[test]
+fn on_component_named_slot_multiple() {
+  let code = transform(
+    "<Comp>
+      <template v-slot:left>
+        foo
+      </template>
+      <template v-slot:right>
+        <Comp v-slot:left>foo</Comp>
+      </template>
+    </Comp>",
+    None,
+  )
+  .code;
+  assert_snapshot!(code);
+}
+
 #[test]
 fn on_component_dynamically_named_slot() {
   let code = transform("<Comp v-slot:$named$={{ foo }}>{ foo + bar }</Comp>", None).code;