@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_ui/src/jsx.rs

@@ -1,7 +1,10 @@
 //! Shared JSX lowering: emit `h(tag, props, children)` as JavaScript or Rust (`Value`) source.
 
+use std::collections::HashSet;
+
 use tishlang_ast::{
-    ArrayElement, Expr, JsxAttrValue, JsxChild, JsxProp, Literal, ObjectProp,
+    ArrayElement, ArrowBody, CallArg, ExportDeclaration, Expr, JsxAttrValue, JsxChild, JsxProp,
+    Literal, MemberProp, ObjectProp, Program, Statement,
 };
 
 /// Escape a Tish identifier for Rust output (matches `tishlang_compile` conventions).
@@ -26,20 +29,29 @@ where
             children,
             ..
         } => {
-            let tag_str = if tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
+            let tag_str = if tag
+                .chars()
+                .next()
+                .map(|c| c.is_uppercase())
+                .unwrap_or(false)
+            {
                 tag.as_ref().to_string()
             } else {
                 format!("{:?}", tag.as_ref())
             };
             let props_str = emit_jsx_props_js(props, emit_expr)?;
-            let children_strs: Result<Vec<_>, _> =
-                children.iter().map(|c| emit_jsx_child_js(c, emit_expr)).collect();
+            let children_strs: Result<Vec<_>, _> = children
+                .iter()
+                .map(|c| emit_jsx_child_js(c, emit_expr))
+                .collect();
             let children_str = children_strs?.join(", ");
             Ok(format!("h({}, {}, [{}])", tag_str, props_str, children_str))
         }
         Expr::JsxFragment { children, .. } => {
-            let children_strs: Result<Vec<_>, _> =
-                children.iter().map(|c| emit_jsx_child_js(c, emit_expr)).collect();
+            let children_strs: Result<Vec<_>, _> = children
+                .iter()
+                .map(|c| emit_jsx_child_js(c, emit_expr))
+                .collect();
             let children_str = children_strs?.join(", ");
             Ok(format!("h(Fragment, null, [{}])", children_str))
         }
@@ -107,8 +119,265 @@ where
     }
 }
 
+/// Every `fn Foo` name in the program (including nested bodies), for Rust JSX tag lowering.
+///
+/// PascalCase JSX tags that match a name here are emitted as a Rust identifier (component
+/// `Value::Function`). Other PascalCase tags become `Value::String("Tag")` (native intrinsics).
+pub fn collect_fun_decl_names(program: &Program) -> HashSet<String> {
+    let mut names = HashSet::new();
+    for s in &program.statements {
+        collect_fun_decl_names_stmt(s, &mut names);
+    }
+    names
+}
+
+fn collect_fun_decl_names_stmt(stmt: &Statement, names: &mut HashSet<String>) {
+    match stmt {
+        Statement::FunDecl { name, body, .. } => {
+            names.insert(name.to_string());
+            collect_fun_decl_names_stmt(body, names);
+        }
+        Statement::Block { statements, .. } => {
+            for s in statements {
+                collect_fun_decl_names_stmt(s, names);
+            }
+        }
+        Statement::VarDecl { init, .. } => {
+            if let Some(e) = init {
+                collect_fun_decl_names_expr(e, names);
+            }
+        }
+        Statement::VarDeclDestructure { init, .. } => collect_fun_decl_names_expr(init, names),
+        Statement::ExprStmt { expr, .. } => collect_fun_decl_names_expr(expr, names),
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            collect_fun_decl_names_expr(cond, names);
+            collect_fun_decl_names_stmt(then_branch, names);
+            if let Some(e) = else_branch {
+                collect_fun_decl_names_stmt(e, names);
+            }
+        }
+        Statement::While { cond, body, .. } => {
+            collect_fun_decl_names_expr(cond, names);
+            collect_fun_decl_names_stmt(body, names);
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
+            if let Some(i) = init {
+                collect_fun_decl_names_stmt(i, names);
+            }
+            if let Some(c) = cond {
+                collect_fun_decl_names_expr(c, names);
+            }
+            if let Some(u) = update {
+                collect_fun_decl_names_expr(u, names);
+            }
+            collect_fun_decl_names_stmt(body, names);
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            collect_fun_decl_names_expr(iterable, names);
+            collect_fun_decl_names_stmt(body, names);
+        }
+        Statement::Return { value, .. } => {
+            if let Some(e) = value {
+                collect_fun_decl_names_expr(e, names);
+            }
+        }
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
+            collect_fun_decl_names_expr(expr, names);
+            for (ce, ss) in cases {
+                if let Some(e) = ce {
+                    collect_fun_decl_names_expr(e, names);
+                }
+                for s in ss {
+                    collect_fun_decl_names_stmt(s, names);
+                }
+            }
+            if let Some(ss) = default_body {
+                for s in ss {
+                    collect_fun_decl_names_stmt(s, names);
+                }
+            }
+        }
+        Statement::DoWhile { body, cond, .. } => {
+            collect_fun_decl_names_stmt(body, names);
+            collect_fun_decl_names_expr(cond, names);
+        }
+        Statement::Throw { value, .. } => collect_fun_decl_names_expr(value, names),
+        Statement::Try {
+            body,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            collect_fun_decl_names_stmt(body, names);
+            if let Some(c) = catch_body {
+                collect_fun_decl_names_stmt(c, names);
+            }
+            if let Some(f) = finally_body {
+                collect_fun_decl_names_stmt(f, names);
+            }
+        }
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => collect_fun_decl_names_stmt(inner, names),
+            ExportDeclaration::Default(e) => collect_fun_decl_names_expr(e, names),
+        },
+        Statement::Import { .. }
+        | Statement::Break { .. }
+        | Statement::Continue { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => {}
+    }
+}
+
+fn collect_fun_decl_names_expr(expr: &Expr, names: &mut HashSet<String>) {
+    match expr {
+        Expr::ArrowFunction { body, .. } => match body {
+            ArrowBody::Expr(e) => collect_fun_decl_names_expr(e, names),
+            ArrowBody::Block(s) => collect_fun_decl_names_stmt(s, names),
+        },
+        Expr::Binary { left, right, .. } => {
+            collect_fun_decl_names_expr(left, names);
+            collect_fun_decl_names_expr(right, names);
+        }
+        Expr::Unary { operand, .. } => collect_fun_decl_names_expr(operand, names),
+        Expr::Assign { value, .. } => collect_fun_decl_names_expr(value, names),
+        Expr::Call { callee, args, .. } => {
+            collect_fun_decl_names_expr(callee, names);
+            for a in args {
+                match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => collect_fun_decl_names_expr(e, names),
+                }
+            }
+        }
+        Expr::Member { object, prop, .. } => {
+            collect_fun_decl_names_expr(object, names);
+            if let MemberProp::Expr(e) = prop {
+                collect_fun_decl_names_expr(e, names);
+            }
+        }
+        Expr::Index { object, index, .. } => {
+            collect_fun_decl_names_expr(object, names);
+            collect_fun_decl_names_expr(index, names);
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            collect_fun_decl_names_expr(cond, names);
+            collect_fun_decl_names_expr(then_branch, names);
+            collect_fun_decl_names_expr(else_branch, names);
+        }
+        Expr::Array { elements, .. } => {
+            for el in elements {
+                match el {
+                    ArrayElement::Expr(e) | ArrayElement::Spread(e) => {
+                        collect_fun_decl_names_expr(e, names);
+                    }
+                }
+            }
+        }
+        Expr::Object { props, .. } => {
+            for p in props {
+                match p {
+                    ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                        collect_fun_decl_names_expr(e, names);
+                    }
+                }
+            }
+        }
+        Expr::NullishCoalesce { left, right, .. } => {
+            collect_fun_decl_names_expr(left, names);
+            collect_fun_decl_names_expr(right, names);
+        }
+        Expr::TemplateLiteral { exprs, .. } => {
+            for e in exprs {
+                collect_fun_decl_names_expr(e, names);
+            }
+        }
+        Expr::Await { operand, .. } | Expr::TypeOf { operand, .. } => {
+            collect_fun_decl_names_expr(operand, names);
+        }
+        Expr::CompoundAssign { value, .. } | Expr::LogicalAssign { value, .. } => {
+            collect_fun_decl_names_expr(value, names);
+        }
+        Expr::MemberAssign { object, value, .. } => {
+            collect_fun_decl_names_expr(object, names);
+            collect_fun_decl_names_expr(value, names);
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            collect_fun_decl_names_expr(object, names);
+            collect_fun_decl_names_expr(index, names);
+            collect_fun_decl_names_expr(value, names);
+        }
+        Expr::New { callee, args, .. } => {
+            collect_fun_decl_names_expr(callee, names);
+            for a in args {
+                match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => collect_fun_decl_names_expr(e, names),
+                }
+            }
+        }
+        Expr::PostfixInc { .. }
+        | Expr::PrefixInc { .. }
+        | Expr::PostfixDec { .. }
+        | Expr::PrefixDec { .. } => {}
+        Expr::JsxElement { props, children, .. } => {
+            for p in props {
+                match p {
+                    JsxProp::Attr { value, .. } => {
+                        if let JsxAttrValue::Expr(e) = value {
+                            collect_fun_decl_names_expr(e, names);
+                        }
+                    }
+                    JsxProp::Spread(e) => collect_fun_decl_names_expr(e, names),
+                }
+            }
+            for c in children {
+                if let JsxChild::Expr(e) = c {
+                    collect_fun_decl_names_expr(e, names);
+                }
+            }
+        }
+        Expr::JsxFragment { children, .. } => {
+            for c in children {
+                if let JsxChild::Expr(e) = c {
+                    collect_fun_decl_names_expr(e, names);
+                }
+            }
+        }
+        Expr::Literal { .. } | Expr::Ident { .. } | Expr::NativeModuleLoad { .. } => {}
+    }
+}
+
 /// Emit JSX as Rust `Value` by calling `tishlang_ui::ui_h` directly (no closure capture of a local `h` binding).
-pub fn emit_jsx_rust<F, E>(expr: &Expr, emit_expr: &mut F) -> Result<String, E>
+pub fn emit_jsx_rust<F, E>(
+    expr: &Expr,
+    emit_expr: &mut F,
+    fun_decls: &HashSet<String>,
+) -> Result<String, E>
 where
     F: FnMut(&Expr) -> Result<String, E>,
     E: From<String>,
@@ -120,9 +389,17 @@ where
             children,
             ..
         } => {
-            let is_component = tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false);
+            let is_component = tag
+                .chars()
+                .next()
+                .map(|c| c.is_uppercase())
+                .unwrap_or(false);
             let tag_rust = if is_component {
-                escape_ident_rust(tag.as_ref())
+                if fun_decls.contains(tag.as_ref()) {
+                    escape_ident_rust(tag.as_ref())
+                } else {
+                    format!("Value::String({:?}.into())", tag.as_ref())
+                }
             } else {
                 format!("Value::String({:?}.into())", tag.as_ref())
             };
@@ -132,7 +409,7 @@ where
                 .map(|c| emit_jsx_child_rust(c, emit_expr))
                 .collect();
             let children_rust = format!(
-                "Value::Array(Rc::new(RefCell::new(vec![{}])))",
+                "Value::Array(VmRef::new(vec![{}]))",
                 child_parts?.join(", ")
             );
             Ok(wrap_h_call_rust(&tag_rust, &props_rust, &children_rust))
@@ -143,14 +420,10 @@ where
                 .map(|c| emit_jsx_child_rust(c, emit_expr))
                 .collect();
             let children_rust = format!(
-                "Value::Array(Rc::new(RefCell::new(vec![{}])))",
+                "Value::Array(VmRef::new(vec![{}]))",
                 child_parts?.join(", ")
             );
-            Ok(wrap_h_call_rust(
-                "Fragment",
-                "Value::Null",
-                &children_rust,
-            ))
+            Ok(wrap_h_call_rust("Fragment", "Value::Null", &children_rust))
         }
         _ => Err(E::from("emit_jsx_rust: not a JSX expression".to_string())),
     }
@@ -200,7 +473,7 @@ where
             }
         }
         Ok(format!(
-            "{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(Rc::new(RefCell::new(_obj))) }}",
+            "{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(VmRef::new(_obj)) }}",
             parts.join(" ")
         ))
     } else {
@@ -222,7 +495,7 @@ where
             }
         }
         Ok(format!(
-            "Value::Object(Rc::new(RefCell::new(ObjectMap::from([{}]))))",
+            "Value::Object(VmRef::new(ObjectMap::from([{}])))",
             kv.join(", ")
         ))
     }
@@ -279,7 +552,13 @@ fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
         Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
             expr_contains_jsx(cond) || stmt_contains_jsx(body)
         }
-        Statement::For { init, cond, update, body, .. } => {
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
             init.as_ref().is_some_and(|s| stmt_contains_jsx(s))
                 || cond.as_ref().is_some_and(expr_contains_jsx)
                 || update.as_ref().is_some_and(expr_contains_jsx)
@@ -288,7 +567,12 @@ fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
         Statement::ForOf { iterable, body, .. } => {
             expr_contains_jsx(iterable) || stmt_contains_jsx(body)
         }
-        Statement::Switch { expr, cases, default_body, .. } => {
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
             expr_contains_jsx(expr)
                 || cases.iter().any(|(e, ss)| {
                     e.as_ref().is_some_and(expr_contains_jsx) || ss.iter().any(stmt_contains_jsx)
@@ -313,7 +597,12 @@ fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
             ExportDeclaration::Named(inner) => stmt_contains_jsx(inner),
             ExportDeclaration::Default(e) => expr_contains_jsx(e),
         },
-        Statement::Import { .. } | Statement::Break { .. } | Statement::Continue { .. } => false,
+        Statement::Import { .. }
+        | Statement::Break { .. }
+        | Statement::Continue { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => false,
     }
 }
 
@@ -372,9 +661,12 @@ fn expr_contains_jsx(expr: &Expr) -> bool {
         Expr::MemberAssign { object, value, .. } => {
             expr_contains_jsx(object) || expr_contains_jsx(value)
         }
-        Expr::IndexAssign { object, index, value, .. } => {
-            expr_contains_jsx(object) || expr_contains_jsx(index) || expr_contains_jsx(value)
-        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => expr_contains_jsx(object) || expr_contains_jsx(index) || expr_contains_jsx(value),
         Expr::New { callee, args, .. } => {
             expr_contains_jsx(callee)
                 || args.iter().any(|a| match a {
@@ -383,8 +675,6 @@ fn expr_contains_jsx(expr: &Expr) -> bool {
                     }
                 })
         }
-        Expr::Literal { .. }
-        | Expr::Ident { .. }
-        | Expr::NativeModuleLoad { .. } => false,
+        Expr::Literal { .. } | Expr::Ident { .. } | Expr::NativeModuleLoad { .. } => false,
     }
 }

package/crates/tish_ui/src/lib.rs

@@ -11,6 +11,9 @@ pub mod runtime;
 
 #[cfg(feature = "runtime")]
 pub use runtime::{
-    fragment_value, install_thread_local_host, native_create_root, native_use_state, ui_h,
-    ui_text, with_thread_local_host, Host, HeadlessHost, FRAGMENT_SENTINEL,
+    alloc_root_id, current_root_id, drop_host_for_root, fragment_value, install_host_for_root,
+    install_thread_local_host, native_create_root, native_use_effect, native_use_memo,
+    native_use_state, run_with_current_root, ui_h, ui_text, unregister_root,
+    unregister_root_hooks_and_effects, with_host_for_root, with_thread_local_host, HeadlessHost, Host,
+    FRAGMENT_SENTINEL, LEGACY_ROOT_ID, RootId,
 };