Template 与 VNode

#[derive(Debug, Clone)]
pub struct VNode {
    vnode: Rc<VNodeInner>,

    /// The mount information for this template
    pub(crate) mount: Cell<MountId>,
}

pub struct VNodeInner {
    pub key: Option<String>,
    pub template: Template,
    pub dynamic_nodes: Box<[DynamicNode]>,
    pub dynamic_attrs: Box<[Box<[Attribute]>]>,
}

impl PartialEq for VNode {
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.vnode, &other.vnode)
    }
}

#[derive(Debug, Clone, Copy, Eq, PartialOrd, Ord)]
pub struct Template {
    pub roots: StaticTemplateArray,
    pub node_paths: StaticPathArray,
    pub attr_paths: StaticPathArray,
}

// Are identical static items merged in the current build. Rust doesn't have a cfg(merge_statics) attribute
// so we have to check this manually
#[allow(unpredictable_function_pointer_comparisons)] // This attribute should be removed once MSRV is 1.85 or greater and the below change is made
fn static_items_merged() -> bool {
    fn a() {}
    fn b() {}
    a as fn() == b as fn()
    // std::ptr::fn_addr_eq(a as fn(), b as fn()) <<<<---- This should replace the a as fn() === b as fn() once the MSRV is 1.85 or greater
}

impl PartialEq for Template {
    fn eq(&self, other: &Self) -> bool {
        // If identical static items are merged, we can compare templates by pointer
        if static_items_merged() {
            std::ptr::eq(self.roots as *const _, other.roots as *const _)
                && std::ptr::eq(self.node_paths as *const _, other.node_paths as *const _)
                && std::ptr::eq(self.attr_paths as *const _, other.attr_paths as *const _)
        }
        // Otherwise, we compare by value
        else {
            self.roots == other.roots
                && self.node_paths == other.node_paths
                && self.attr_paths == other.attr_paths
        }
    }
}

const N: i32 = 1;

fn app() -> Element {
  if FLAG.with(|f| f.get()) {
    rsx! { div { "{N}" } }
  } else {
    rsx! { div { "{N}" } }
  }
}

fn main() {
  println!("debug_assertions = {}", cfg!(debug_assertions));
  println!("static_items_merged() = {}", static_items_merged()); // 照抄 core 里的那个私有函数
  let mut dom = VirtualDom::new(app);
  dom.rebuild_to_vec();
  let a = app().unwrap();
  FLAG.with(|f| f.set(true));
  let b = app().unwrap();
  println!(
    "ptr equal: roots={} node_paths={} attr_paths={}; Template == : {}",
    std::ptr::eq(a.template.roots, b.template.roots),
    std::ptr::eq(a.template.node_paths, b.template.node_paths),
    std::ptr::eq(a.template.attr_paths, b.template.attr_paths),
    a.template == b.template
  );
  dom.mark_dirty(ScopeId::APP);
  let edits = dom.render_immediate_to_vec();
  println!("{:?}", edits.edits);
}

debug_assertions = true
static_items_merged() = false
ptr equal: roots=true node_paths=false attr_paths=true; Template == : true
[]
---release
debug_assertions = false
static_items_merged() = true
ptr equal: roots=true node_paths=true attr_paths=true; Template == : true
[]

pub enum TemplateNode {
    Element {
        tag: StaticStr,
        namespace: Option<StaticStr>,
        attrs: StaticTemplateAttributeArray,
        children: StaticTemplateArray,
    },
    Text {
        text: StaticStr,
    },
    Dynamic {
        id: usize,
    },
}

pub enum DynamicNode {
    Component(VComponent),
    Text(VText),
    Placeholder(VPlaceholder),
    Fragment(Vec<VNode>),
}

pub enum AttributeValue {
    /// Text attribute
    Text(String),

    /// A float
    Float(f64),

    /// Signed integer
    Int(i64),

    /// Boolean
    Bool(bool),

    /// A listener, like "onclick"
    Listener(ListenerCallback),

    /// An arbitrary value that implements PartialEq and is static
    Any(Rc<dyn AnyValue>),

    /// A "none" value, resulting in the removal of an attribute from the dom
    None,
}

    pub type Element = std::result::Result<VNode, RenderError>;

  let a = hello().unwrap();
  let a2 = a.clone();
  let b = hello().unwrap();
  println!("clone == original: {}; two renders ==: {}; same template: {}", a == a2, a == b, a.template == b.template);
  println!("two placeholders ==: {}", VNode::placeholder() == VNode::placeholder());

  let none: Option<&str> = None;
  let empty = std::iter::empty::<Element>();
  let err: Element = Err(RenderError::default());
  println!("()                -> {}", label(().into_dyn_node()));
  println!("\"text\"            -> {}", label("text".into_dyn_node()));
  // ... String、format_args!、Some("x")、None、VNode、Ok(VNode) 同理
  println!("Err(RenderError)  -> {}", label(err.into_dyn_node()));
  println!("iter of 3 Element -> {}", label((0..3).map(|_| hello()).into_dyn_node()));
  println!("empty iter        -> {}", label(empty.into_dyn_node()));

size_of: VNode=16 Template=48 TemplateNode=72 DynamicNode=48 Attribute=72 AttributeValue=32 Element=24
clone == original: true; two renders ==: false; same template: true
two placeholders ==: true
()                -> Placeholder
"text"            -> Text("text")
String            -> Text("s")
format_args!      -> Text("1+2")
Some("x")         -> Text("x")
None::<&str>      -> Placeholder
VNode             -> Fragment(len=1)
Ok(VNode)         -> Fragment(len=1)
Err(RenderError)  -> Placeholder
iter of 3 Element -> Fragment(len=3)
empty iter        -> Placeholder