Performance improvements

.github/workflows/js_framework_bench.yml

@@ -16,7 +16,7 @@ jobs:
 
     env:
       MSG_FOOTER: |
-        <br/>
+
         Workflow: [${{ github.run_id }}](/${{ github.repository }}/actions/runs/${{ github.run_id }})
         *Adding new commits will generate a new report*
 

packages/sycamore-macro/src/template/element.rs

@@ -5,7 +5,7 @@ use quote::{quote, quote_spanned, ToTokens};
 use syn::ext::IdentExt;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::spanned::Spanned;
-use syn::{token, Ident, Token};
+use syn::{token, Expr, Ident, Token};
 
 use super::*;
 
@@ -62,8 +62,23 @@ impl ToTokens for Element {
             let multi = children.body.len() != 1;
             let mut children = children.body.iter().peekable();
             while let Some(child) = children.next() {
+                // True if the child is a component or a splice that is not a simple path.
+                // Example:
+                // template! { MyComponent() } // is_dynamic = true
+                // template! { (state.get()) } // is_dynamic = true
+                // template! { (state) } // is_dynamic = false
+                let is_dynamic = match child {
+                    HtmlTree::Component(_) => true,
+                    HtmlTree::Text(Text::Splice(_, expr))
+                        if !matches!(expr.as_ref(), Expr::Path(_)) =>
+                    {
+                        true
+                    }
+                    _ => false,
+                };
+
                 quoted.extend(match child {
-                    HtmlTree::Component(_) | HtmlTree::Text(Text::Splice(..)) => {
+                    _ if is_dynamic => {
                         let quote_marker =
                         if let Some(HtmlTree::Element(element)) =
                             children.next_if(|x| matches!(x, HtmlTree::Element(_)))
@@ -123,6 +138,17 @@ impl ToTokens for Element {
                             &::sycamore::generic_node::GenericNode::text_node(#text),
                         );
                     },
+                    HtmlTree::Text(text @ Text::Splice(..)) => {
+                        assert!(!is_dynamic);
+                        quote_spanned! { text.span()=>
+                            ::sycamore::utils::render::insert(
+                                &__el,
+                                ::sycamore::template::IntoTemplate::create(&#text),
+                                None, None, #multi
+                            );
+                        }
+                    },
+                    _ => unreachable!("all branches covered by match guards"),
                 });
             }
         }

packages/sycamore/Cargo.toml

@@ -19,6 +19,7 @@ html-escape = {version = "0.2.7", optional = true}
 indexmap = "1.7"
 js-sys = {version = "0.3", optional = true}
 serde = {version = "1.0", optional = true}
+smallvec = "1.6"
 sycamore-macro = {path = "../sycamore-macro", version = "=0.5.0"}
 wasm-bindgen = {version = "0.2", optional = true, features = ["enable-interning"]}
 

packages/sycamore/src/generic_node/dom_node.rs

@@ -306,8 +306,7 @@ fn get_children(parent: &Element) -> Vec<Element> {
     let children = parent.children();
     let children_count = children.length();
 
-    let mut vec = Vec::new();
-    vec.reserve(children_count as usize);
+    let mut vec = Vec::with_capacity(children_count as usize);
 
     for i in 0..children.length() {
         vec.push(children.get_with_index(i).unwrap());

packages/sycamore/src/rx/effect.rs

@@ -7,14 +7,23 @@ use std::ptr;
 use std::rc::Rc;
 use std::rc::Weak;
 
+use smallvec::SmallVec;
+
 use super::*;
 
+/// The number of effects that are allocated on the stack before resorting to heap allocation in
+/// [`ReactiveScope`].
+const REACTIVE_SCOPE_EFFECTS_STACK_CAPACITY: usize = 4;
+
+/// Initial capacity for [`CONTEXTS`].
+const CONTEXTS_INITIAL_CAPACITY: usize = 10;
+
 thread_local! {
     /// Context of the effect that is currently running. `None` if no effect is running.
     ///
     /// This is an array of callbacks that, when called, will add the a `Signal` to the `handle` in the argument.
     /// The callbacks return another callback which will unsubscribe the `handle` from the `Signal`.
-    pub(super) static CONTEXTS: RefCell<Vec<Weak<RefCell<Option<Running>>>>> = RefCell::new(Vec::new());
+    pub(super) static CONTEXTS: RefCell<Vec<Weak<RefCell<Option<Running>>>>> = RefCell::new(Vec::with_capacity(CONTEXTS_INITIAL_CAPACITY));
     pub(super) static SCOPE: RefCell<Option<ReactiveScope>> = RefCell::new(None);
 }
 
@@ -42,19 +51,13 @@ impl Running {
     }
 }
 
-impl Drop for Running {
-    fn drop(&mut self) {
-        self.clear_dependencies();
-    }
-}
-
 /// Owns the effects created in the current reactive scope.
 /// The effects are dropped and the cleanup callbacks are called when the [`ReactiveScope`] is
 /// dropped.
 #[derive(Default)]
 pub struct ReactiveScope {
     /// Effects created in this scope.
-    effects: Vec<Rc<RefCell<Option<Running>>>>,
+    effects: SmallVec<[Rc<RefCell<Option<Running>>>; REACTIVE_SCOPE_EFFECTS_STACK_CAPACITY]>,
     /// Callbacks to call when the scope is dropped.
     cleanup: Vec<Box<dyn FnOnce()>>,
 }

packages/sycamore/src/rx/iter.rs

@@ -93,7 +93,7 @@ where
 
                 // 0) Prepare a map of indices in newItems. Scan backwards so we encounter them in
                 // natural order.
-                let mut new_indices = HashMap::new();
+                let mut new_indices = HashMap::with_capacity(new_end - start);
 
                 // Indexes for new_indices_next are shifted by start because values at 0..start are
                 // always None.

packages/sycamore/src/utils/render.rs

@@ -300,7 +300,7 @@ pub fn reconcile_fragments<G: GenericNode>(parent: &G, a: &mut [G], b: &[G]) {
         } else {
             // Fallback to map.
             if map.is_none() {
-                map = Some(HashMap::new());
+                map = Some(HashMap::with_capacity(b_end - b_start));
                 for (i, item) in b.iter().enumerate().take(b_end).skip(b_start) {
                     map.as_mut().unwrap().insert(item.clone(), i);
                 }