@tishlang/tish 2.2.0 → 2.2.4

package/crates/tish_resolve/src/lib.rs

@@ -72,6 +72,35 @@ fn synthetic_name_span(start: (usize, usize), name: &str) -> tishlang_ast::Span
     }
 }
 
+thread_local! {
+    /// When active, accumulates the definition spans that identifier uses resolve to during one
+    /// `collect_unresolved_identifiers` scope-aware walk (`record_unresolved` already resolves every
+    /// use). `collect_unused_bindings` activates it to learn which declarations are referenced in a
+    /// single O(N) pass, instead of re-scanning the whole program per binding (which was ~O(N³) and
+    /// froze large files). Inactive for normal callers (the unresolved-name diagnostic), which see
+    /// no behavior change.
+    static REFERENCED_DEFS: std::cell::RefCell<Option<std::collections::HashSet<(usize, usize)>>> =
+        const { std::cell::RefCell::new(None) };
+}
+
+/// One scope-aware resolution pass: the set of definition span *starts* that at least one identifier
+/// use resolves to (a name's declaration position is unique, so the start identifies it). Reuses the
+/// exact walk and scope rules of [`collect_unresolved_identifiers`], so it stays consistent with the
+/// unresolved-name diagnostic. O(N) (single walk; scope lookups O(1)).
+fn collect_referenced_def_spans(program: &Program) -> std::collections::HashSet<(usize, usize)> {
+    struct Guard;
+    impl Drop for Guard {
+        fn drop(&mut self) {
+            REFERENCED_DEFS.with(|r| *r.borrow_mut() = None);
+        }
+    }
+    let _g = Guard;
+    REFERENCED_DEFS.with(|r| *r.borrow_mut() = Some(std::collections::HashSet::new()));
+    // Side effect: record_unresolved inserts each resolved def span into REFERENCED_DEFS.
+    let _ = collect_unresolved_identifiers(program);
+    REFERENCED_DEFS.with(|r| r.borrow_mut().take().unwrap_or_default())
+}
+
 fn collect_stmt(
     stmt: &Statement,
     source: &str,
@@ -160,6 +189,7 @@ fn collect_stmt(
             name,
             name_span,
             params,
+            rest_param,
             body,
             ..
         } => {
@@ -167,6 +197,9 @@ fn collect_stmt(
             for p in params {
                 collect_fun_param(p, source, lsp_line, lsp_char, best);
             }
+            if let Some(rp) = rest_param {
+                consider(source, lsp_line, lsp_char, &rp.name_span, rp.name.clone(), best);
+            }
             collect_stmt(body, source, lsp_line, lsp_char, best);
         }
         Statement::Switch {
@@ -256,12 +289,16 @@ fn collect_stmt(
             name,
             name_span,
             params,
+            rest_param,
             ..
         } => {
             consider(source, lsp_line, lsp_char, name_span, name.clone(), best);
             for p in params {
                 collect_fun_param(p, source, lsp_line, lsp_char, best);
             }
+            if let Some(rp) = rest_param {
+                consider(source, lsp_line, lsp_char, &rp.name_span, rp.name.clone(), best);
+            }
         }
         Statement::Break { .. } | Statement::Continue { .. } => {}
     }
@@ -484,8 +521,21 @@ fn collect_expr(
         }
         Expr::Await { operand, .. } => collect_expr(operand, source, lsp_line, lsp_char, best),
         Expr::JsxElement {
-            props, children, ..
+            tag,
+            tag_span,
+            close_tag_span,
+            props,
+            children,
+            ..
         } => {
+            // A PascalCase tag references a component binding (`<Foo/>` lowers to `h(Foo, …)`); let
+            // the cursor land on it (opening or closing tag) for hover / go-to-def / rename.
+            if tag.chars().next().is_some_and(|c| c.is_uppercase()) {
+                consider(source, lsp_line, lsp_char, tag_span, tag.clone(), best);
+                if let Some(cs) = close_tag_span {
+                    consider(source, lsp_line, lsp_char, cs, tag.clone(), best);
+                }
+            }
             for p in props {
                 match p {
                     tishlang_ast::JsxProp::Attr { value, .. } => if let tishlang_ast::JsxAttrValue::Expr(e) = value {
@@ -1021,6 +1071,48 @@ fn define_pattern_stack(pattern: &DestructPattern, scopes: &mut ScopeStack) {
     }
 }
 
+/// Pre-define hoisted function-declaration names (incl. `export fn` and ambient `declare fn`) for a
+/// statement list, so a reference to a function declared later in the same scope resolves. Function
+/// values capture the live scope, so calling a sibling function declared further down succeeds at
+/// runtime (e.g. mutual recursion, or a helper defined below its caller); the resolver mirrors that
+/// by defining the names before walking any sibling body. Only function names are hoisted — `let`
+/// is not, matching the interpreter.
+fn hoist_fn_names(stmts: &[Statement], scopes: &mut ScopeStack) {
+    for s in stmts {
+        match s {
+            Statement::FunDecl {
+                name, name_span, ..
+            }
+            | Statement::DeclareFun {
+                name, name_span, ..
+            } => {
+                scopes.define(name.as_ref(), *name_span);
+            }
+            Statement::Export { declaration, .. } => {
+                if let ExportDeclaration::Named(inner) = declaration.as_ref() {
+                    if let Statement::FunDecl {
+                        name, name_span, ..
+                    } = inner.as_ref()
+                    {
+                        scopes.define(name.as_ref(), *name_span);
+                    }
+                }
+            }
+            Statement::Multi { statements, .. } => hoist_fn_names(statements, scopes),
+            _ => {}
+        }
+    }
+}
+
+/// The default-value expression of a parameter, if any (`fn f(a = EXPR)`). Both simple and
+/// destructuring parameters can carry a default; rest parameters never do (no default syntax).
+fn param_default(p: &FunParam) -> Option<&Expr> {
+    match p {
+        FunParam::Simple(tp) => tp.default.as_ref(),
+        FunParam::Destructure { default, .. } => default.as_ref(),
+    }
+}
+
 fn walk_expr_resolve(
     expr: &Expr,
     scopes: &ScopeStack,
@@ -1148,6 +1240,13 @@ fn walk_expr_resolve(
             for p in params {
                 define_fun_param_stack(p, &mut inner);
             }
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    if let Some(s) = walk_expr_resolve(e, &inner, target) {
+                        return Some(s);
+                    }
+                }
+            }
             match body {
                 ArrowBody::Expr(e) => walk_expr_resolve(e, &inner, target),
                 ArrowBody::Block(b) => walk_stmt_resolve(b, &mut inner, target),
@@ -1163,8 +1262,20 @@ fn walk_expr_resolve(
         }
         Expr::Await { operand, .. } => walk_expr_resolve(operand, scopes, target),
         Expr::JsxElement {
-            props, children, ..
+            tag,
+            tag_span,
+            close_tag_span,
+            props,
+            children,
+            ..
         } => {
+            // Go-to-def on a PascalCase component tag (opening or closing) resolves to its binding.
+            if tag.chars().next().is_some_and(|c| c.is_uppercase())
+                && (*tag_span == tgt || *close_tag_span == Some(tgt))
+                && tag.as_ref() == target.name.as_ref()
+            {
+                return scopes.resolve(tag.as_ref());
+            }
             for p in props {
                 match p {
                     tishlang_ast::JsxProp::Attr { value, .. } => {
@@ -1307,6 +1418,7 @@ fn walk_stmt_resolve(
             .and_then(|e| walk_expr_resolve(e, scopes, target)),
         Statement::Block { statements, .. } => {
             scopes.push();
+            hoist_fn_names(statements, scopes);
             let mut out = None;
             for s in statements {
                 if let Some(x) = walk_stmt_resolve(s, scopes, target) {
@@ -1332,6 +1444,7 @@ fn walk_stmt_resolve(
             name,
             name_span,
             params,
+            rest_param,
             body,
             ..
         } => {
@@ -1343,7 +1456,21 @@ fn walk_stmt_resolve(
             for p in params {
                 define_fun_param_stack(p, scopes);
             }
-            let r = walk_stmt_resolve(body, scopes, target);
+            if let Some(rp) = rest_param {
+                scopes.define(rp.name.as_ref(), rp.name_span);
+            }
+            let mut r = None;
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    if let Some(s) = walk_expr_resolve(e, scopes, target) {
+                        r = Some(s);
+                        break;
+                    }
+                }
+            }
+            if r.is_none() {
+                r = walk_stmt_resolve(body, scopes, target);
+            }
             scopes.pop();
             if r.is_some() {
                 return r;
@@ -1482,6 +1609,7 @@ fn walk_stmt_resolve(
             name,
             name_span,
             params,
+            rest_param,
             ..
         } => {
             if *name_span == tgt_span && name.as_ref() == target.name.as_ref() {
@@ -1492,8 +1620,20 @@ fn walk_stmt_resolve(
             for p in params {
                 define_fun_param_stack(p, scopes);
             }
+            if let Some(rp) = rest_param {
+                scopes.define(rp.name.as_ref(), rp.name_span);
+            }
+            let mut r = None;
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    if let Some(s) = walk_expr_resolve(e, scopes, target) {
+                        r = Some(s);
+                        break;
+                    }
+                }
+            }
             scopes.pop();
-            None
+            r
         }
         Statement::Break { .. } | Statement::Continue { .. } => None,
     }
@@ -1524,6 +1664,11 @@ pub struct UnresolvedIdentifier {
 /// Names always present on the interpreter root scope (see `tishlang_eval`) and listed in
 /// `stdlib/builtins.d.tish`. They must not produce "unresolved identifier" diagnostics when
 /// used without a `let`/`import`.
+///
+/// NOTE: maintained by hand to track the globals the interpreter registers on its root scope
+/// (`tish_eval`). It is the only suppression the LSP has — the resolver does not load
+/// `builtins.d.tish` — so any global missing here surfaces as a false `tish-unresolved-name`
+/// error in the editor. Keep it in sync (see the `runtime_globals_not_unresolved` test).
 pub fn is_runtime_global_ident(name: &str) -> bool {
     matches!(
         name,
@@ -1533,6 +1678,7 @@ pub fn is_runtime_global_ident(name: &str) -> bool {
             | "decodeURI"
             | "encodeURI"
             | "Boolean"
+            | "Number"
             | "isFinite"
             | "isNaN"
             | "Infinity"
@@ -1542,6 +1688,7 @@ pub fn is_runtime_global_ident(name: &str) -> bool {
             | "Object"
             | "Array"
             | "String"
+            | "Symbol"
             | "Date"
             | "Set"
             | "Map"
@@ -1556,6 +1703,15 @@ pub fn is_runtime_global_ident(name: &str) -> bool {
             | "Uint32Array"
             | "AudioContext"
             | "RegExp"
+            | "Error"
+            | "TypeError"
+            | "RangeError"
+            | "SyntaxError"
+            | "Promise"
+            | "fetch"
+            | "fetchAll"
+            | "serve"
+            | "htmlEscape"
             | "setTimeout"
             | "setInterval"
             | "clearTimeout"
@@ -1569,14 +1725,25 @@ fn record_unresolved(
     span: tishlang_ast::Span,
     out: &mut Vec<UnresolvedIdentifier>,
 ) {
-    if is_runtime_global_ident(name.as_ref()) {
-        return;
-    }
-    if scopes.resolve(name.as_ref()).is_none() {
-        out.push(UnresolvedIdentifier {
-            name: name.clone(),
-            span,
-        });
+    match scopes.resolve(name.as_ref()) {
+        // Resolved to an in-scope declaration. Record it (when collection is active) so
+        // collect_unused_bindings learns this def is referenced — done before the global check so a
+        // local that shadows a global name still counts as a use. Unresolved-name output unchanged.
+        Some(def) => {
+            REFERENCED_DEFS.with(|r| {
+                if let Some(set) = r.borrow_mut().as_mut() {
+                    set.insert(def.start);
+                }
+            });
+        }
+        None => {
+            if !is_runtime_global_ident(name.as_ref()) {
+                out.push(UnresolvedIdentifier {
+                    name: name.clone(),
+                    span,
+                });
+            }
+        }
     }
 }
 
@@ -1695,6 +1862,11 @@ fn check_unresolved_expr(expr: &Expr, scopes: &ScopeStack, out: &mut Vec<Unresol
             for p in params {
                 define_fun_param_stack(p, &mut inner);
             }
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    check_unresolved_expr(e, &inner, out);
+                }
+            }
             match body {
                 ArrowBody::Expr(e) => check_unresolved_expr(e, &inner, out),
                 ArrowBody::Block(b) => check_unresolved_stmt(b, &mut inner, out),
@@ -1828,6 +2000,7 @@ fn check_unresolved_stmt(
         }
         Statement::Block { statements, .. } => {
             scopes.push();
+            hoist_fn_names(statements, scopes);
             for s in statements {
                 check_unresolved_stmt(s, scopes, out);
             }
@@ -1843,6 +2016,7 @@ fn check_unresolved_stmt(
             name,
             name_span,
             params,
+            rest_param,
             body,
             ..
         } => {
@@ -1851,6 +2025,14 @@ fn check_unresolved_stmt(
             for p in params {
                 define_fun_param_stack(p, scopes);
             }
+            if let Some(rp) = rest_param {
+                scopes.define(rp.name.as_ref(), rp.name_span);
+            }
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    check_unresolved_expr(e, scopes, out);
+                }
+            }
             check_unresolved_stmt(body, scopes, out);
             scopes.pop();
             scopes.define(name.as_ref(), *name_span);
@@ -1944,6 +2126,7 @@ fn check_unresolved_stmt(
             name,
             name_span,
             params,
+            rest_param,
             ..
         } => {
             scopes.push();
@@ -1951,6 +2134,14 @@ fn check_unresolved_stmt(
             for p in params {
                 define_fun_param_stack(p, scopes);
             }
+            if let Some(rp) = rest_param {
+                scopes.define(rp.name.as_ref(), rp.name_span);
+            }
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    check_unresolved_expr(e, scopes, out);
+                }
+            }
             scopes.pop();
             scopes.define(name.as_ref(), *name_span);
         }
@@ -1962,6 +2153,7 @@ fn check_unresolved_stmt(
 pub fn collect_unresolved_identifiers(program: &Program) -> Vec<UnresolvedIdentifier> {
     let mut out = Vec::new();
     let mut scopes = ScopeStack::new();
+    hoist_fn_names(&program.statements, &mut scopes);
     for stmt in &program.statements {
         check_unresolved_stmt(stmt, &mut scopes, &mut out);
     }
@@ -2424,59 +2616,291 @@ fn enumerate_stmt(stmt: &Statement, exported: bool, out: &mut Vec<BindingSite>)
                 exported,
             });
         }
-        Statement::DeclareVar {
-            name, name_span, ..
+        // Ambient `declare` declarations describe symbols defined elsewhere and have no body, so
+        // nothing here is ever "unused" within this file (params can't be read; the name is API
+        // surface for other modules). They contribute no unused-binding candidates.
+        Statement::DeclareVar { .. } | Statement::DeclareFun { .. } => {}
+        Statement::Break { .. } | Statement::Continue { .. } => {}
+    }
+}
+
+/// Collect PascalCase JSX component tag names used anywhere in `program`. A `<Foo/>` tag lowers to
+/// `h(Foo, …)` — a real reference to the `Foo` binding — but the tag is not a span-validated
+/// identifier use, so the reference walker misses it. Used by [`collect_unused_bindings`] to avoid
+/// flagging a component import/binding used only as a tag. (Lowercase tags lower to string
+/// literals, so they are not references.) Precise rename/find-references for tags still needs a
+/// real tag span in the AST and is handled separately.
+fn collect_jsx_component_tags(program: &Program) -> std::collections::HashSet<Arc<str>> {
+    let mut out = std::collections::HashSet::new();
+    for s in &program.statements {
+        jsx_tags_stmt(s, &mut out);
+    }
+    out
+}
+
+fn jsx_tags_stmt(s: &Statement, out: &mut std::collections::HashSet<Arc<str>>) {
+    match s {
+        Statement::VarDecl { init, .. } => {
+            if let Some(e) = init {
+                jsx_tags_expr(e, out);
+            }
+        }
+        Statement::VarDeclDestructure { init, .. } => jsx_tags_expr(init, out),
+        Statement::ExprStmt { expr, .. } => jsx_tags_expr(expr, out),
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
         } => {
-            out.push(BindingSite {
-                name: name.clone(),
-                span: *name_span,
-                kind: UnusedBindingKind::Variable,
-                exported,
-            });
+            jsx_tags_expr(cond, out);
+            jsx_tags_stmt(then_branch, out);
+            if let Some(b) = else_branch {
+                jsx_tags_stmt(b, out);
+            }
         }
-        Statement::DeclareFun {
-            name,
-            name_span,
-            params,
-            rest_param,
+        Statement::While { cond, body, .. } => {
+            jsx_tags_expr(cond, out);
+            jsx_tags_stmt(body, out);
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
             ..
         } => {
-            out.push(BindingSite {
-                name: name.clone(),
-                span: *name_span,
-                kind: UnusedBindingKind::Variable,
-                exported,
-            });
+            if let Some(i) = init {
+                jsx_tags_stmt(i, out);
+            }
+            if let Some(e) = cond {
+                jsx_tags_expr(e, out);
+            }
+            if let Some(e) = update {
+                jsx_tags_expr(e, out);
+            }
+            jsx_tags_stmt(body, out);
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            jsx_tags_expr(iterable, out);
+            jsx_tags_stmt(body, out);
+        }
+        Statement::Return { value, .. } => {
+            if let Some(e) = value {
+                jsx_tags_expr(e, out);
+            }
+        }
+        Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+            for s in statements {
+                jsx_tags_stmt(s, out);
+            }
+        }
+        Statement::FunDecl { params, body, .. } => {
             for p in params {
-                enumerate_fun_param(p, exported, out);
+                if let Some(e) = param_default(p) {
+                    jsx_tags_expr(e, out);
+                }
             }
-            if let Some(r) = rest_param {
-                out.push(BindingSite {
-                    name: r.name.clone(),
-                    span: r.name_span,
-                    kind: UnusedBindingKind::Parameter,
-                    exported,
-                });
+            jsx_tags_stmt(body, out);
+        }
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
+            jsx_tags_expr(expr, out);
+            for (_, stmts) in cases {
+                for s in stmts {
+                    jsx_tags_stmt(s, out);
+                }
+            }
+            if let Some(stmts) = default_body {
+                for s in stmts {
+                    jsx_tags_stmt(s, out);
+                }
             }
         }
-        Statement::Break { .. } | Statement::Continue { .. } => {}
+        Statement::DoWhile { body, cond, .. } => {
+            jsx_tags_stmt(body, out);
+            jsx_tags_expr(cond, out);
+        }
+        Statement::Throw { value, .. } => jsx_tags_expr(value, out),
+        Statement::Try {
+            body,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            jsx_tags_stmt(body, out);
+            if let Some(cb) = catch_body {
+                jsx_tags_stmt(cb, out);
+            }
+            if let Some(fb) = finally_body {
+                jsx_tags_stmt(fb, out);
+            }
+        }
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => jsx_tags_stmt(inner, out),
+            ExportDeclaration::Default(e) => jsx_tags_expr(e, out),
+        },
+        Statement::Import { .. }
+        | Statement::Break { .. }
+        | Statement::Continue { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => {}
+    }
+}
+
+fn jsx_tags_expr(e: &Expr, out: &mut std::collections::HashSet<Arc<str>>) {
+    match e {
+        Expr::JsxElement {
+            tag,
+            props,
+            children,
+            ..
+        } => {
+            if tag.chars().next().is_some_and(|c| c.is_uppercase()) {
+                out.insert(tag.clone());
+            }
+            for p in props {
+                match p {
+                    tishlang_ast::JsxProp::Attr { value, .. } => {
+                        if let tishlang_ast::JsxAttrValue::Expr(e) = value {
+                            jsx_tags_expr(e, out);
+                        }
+                    }
+                    tishlang_ast::JsxProp::Spread(e) => jsx_tags_expr(e, out),
+                }
+            }
+            for ch in children {
+                if let tishlang_ast::JsxChild::Expr(e) = ch {
+                    jsx_tags_expr(e, out);
+                }
+            }
+        }
+        Expr::JsxFragment { children, .. } => {
+            for ch in children {
+                if let tishlang_ast::JsxChild::Expr(e) = ch {
+                    jsx_tags_expr(e, out);
+                }
+            }
+        }
+        Expr::Binary { left, right, .. } | Expr::NullishCoalesce { left, right, .. } => {
+            jsx_tags_expr(left, out);
+            jsx_tags_expr(right, out);
+        }
+        Expr::Unary { operand, .. }
+        | Expr::TypeOf { operand, .. }
+        | Expr::Await { operand, .. } => jsx_tags_expr(operand, out),
+        Expr::Delete { target, .. } => jsx_tags_expr(target, out),
+        Expr::Call { callee, args, .. } | Expr::New { callee, args, .. } => {
+            jsx_tags_expr(callee, out);
+            for a in args {
+                match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => jsx_tags_expr(e, out),
+                }
+            }
+        }
+        Expr::Member { object, .. } => jsx_tags_expr(object, out),
+        Expr::Index { object, index, .. } => {
+            jsx_tags_expr(object, out);
+            jsx_tags_expr(index, out);
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            jsx_tags_expr(cond, out);
+            jsx_tags_expr(then_branch, out);
+            jsx_tags_expr(else_branch, out);
+        }
+        Expr::Array { elements, .. } => {
+            for el in elements {
+                match el {
+                    tishlang_ast::ArrayElement::Expr(e)
+                    | tishlang_ast::ArrayElement::Spread(e) => jsx_tags_expr(e, out),
+                }
+            }
+        }
+        Expr::Object { props, .. } => {
+            for p in props {
+                match p {
+                    tishlang_ast::ObjectProp::KeyValue(_, e)
+                    | tishlang_ast::ObjectProp::Spread(e) => jsx_tags_expr(e, out),
+                }
+            }
+        }
+        Expr::Assign { value, .. }
+        | Expr::CompoundAssign { value, .. }
+        | Expr::LogicalAssign { value, .. } => jsx_tags_expr(value, out),
+        Expr::MemberAssign { object, value, .. } => {
+            jsx_tags_expr(object, out);
+            jsx_tags_expr(value, out);
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            jsx_tags_expr(object, out);
+            jsx_tags_expr(index, out);
+            jsx_tags_expr(value, out);
+        }
+        Expr::ArrowFunction { params, body, .. } => {
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    jsx_tags_expr(e, out);
+                }
+            }
+            match body {
+                ArrowBody::Expr(e) => jsx_tags_expr(e, out),
+                ArrowBody::Block(b) => jsx_tags_stmt(b, out),
+            }
+        }
+        Expr::TemplateLiteral { exprs, .. } => {
+            for e in exprs {
+                jsx_tags_expr(e, out);
+            }
+        }
+        Expr::Ident { .. }
+        | Expr::Literal { .. }
+        | Expr::NativeModuleLoad { .. }
+        | Expr::PostfixInc { .. }
+        | Expr::PostfixDec { .. }
+        | Expr::PrefixInc { .. }
+        | Expr::PrefixDec { .. } => {}
     }
 }
 
 /// Declarations whose values are never read (imports, locals, parameters). Skips `exported` module
 /// bindings and names starting with `_` (common intentional-unused convention).
-pub fn collect_unused_bindings(program: &Program, source: &str) -> Vec<UnusedBinding> {
+pub fn collect_unused_bindings(program: &Program, _source: &str) -> Vec<UnusedBinding> {
     let mut sites = Vec::new();
     for s in &program.statements {
         enumerate_stmt(s, false, &mut sites);
     }
+    // A binding used only as a PascalCase JSX component tag (`<Foo/>`) is genuinely used — the
+    // resolution walk can't see the tag, so consult the tag set to avoid a false "unused" report
+    // (deleting such an import would break the build).
+    let jsx_tags = collect_jsx_component_tags(program);
+    // Which declarations are referenced, learned in ONE scope-aware pass. The previous approach
+    // re-scanned the whole program per binding (re-resolving each use), which was ~O(N³) and froze
+    // large files; this is O(N). A binding is unused iff nothing resolves to its definition span.
+    let referenced = collect_referenced_def_spans(program);
     let mut out = Vec::new();
     for site in sites {
         if site.exported || site.name.as_ref().starts_with('_') {
             continue;
         }
-        let refs = reference_spans_for_def(program, source, site.name.as_ref(), site.span);
-        if refs.len() == 1 {
+        if jsx_tags.contains(&site.name) {
+            continue;
+        }
+        if !referenced.contains(&site.span.start) {
             out.push(UnusedBinding {
                 name: site.name,
                 span: site.span,
@@ -2496,6 +2920,7 @@ pub fn definition_span(
 ) -> Option<tishlang_ast::Span> {
     let use_site = name_at_cursor(program, source, lsp_line, lsp_character)?;
     let mut scopes = ScopeStack::new();
+    hoist_fn_names(&program.statements, &mut scopes);
     for stmt in &program.statements {
         if let Some(s) = walk_stmt_resolve(stmt, &mut scopes, &use_site) {
             return Some(s);
@@ -3233,19 +3658,20 @@ fn refs_stmt(
         }
         Statement::FunDecl { params, body, .. } => {
             for p in params {
-                if let FunParam::Simple(tp) = p {
-                    if let Some(e) = &tp.default {
-                        refs_expr(e, program, source, name, def_span, out);
-                    }
-                } else if let FunParam::Destructure {
-                    default: Some(e), ..
-                } = p
-                {
+                if let Some(e) = param_default(p) {
                     refs_expr(e, program, source, name, def_span, out);
                 }
             }
             refs_stmt(body, program, source, name, def_span, out);
         }
+        // Ambient `declare fn` params can carry value-level defaults too.
+        Statement::DeclareFun { params, .. } => {
+            for p in params {
+                if let Some(e) = param_default(p) {
+                    refs_expr(e, program, source, name, def_span, out);
+                }
+            }
+        }
         Statement::Switch {
             expr,
             cases,
@@ -3283,13 +3709,19 @@ fn refs_stmt(
                 refs_stmt(fb, program, source, name, def_span, out);
             }
         }
+        // Descend into exported declarations so references inside `export fn`/`export let`/
+        // `export default` bodies are counted (otherwise a binding used only there looks unused).
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => {
+                refs_stmt(inner, program, source, name, def_span, out)
+            }
+            ExportDeclaration::Default(e) => refs_expr(e, program, source, name, def_span, out),
+        },
         Statement::Import { .. }
-        | Statement::Export { .. }
         | Statement::Break { .. }
         | Statement::Continue { .. }
         | Statement::TypeAlias { .. }
-        | Statement::DeclareVar { .. }
-        | Statement::DeclareFun { .. } => {}
+        | Statement::DeclareVar { .. } => {}
     }
 }
 
@@ -3458,8 +3890,22 @@ fn refs_expr(
         }
         Expr::Await { operand, .. } => refs_expr(operand, program, source, name, def_span, out),
         Expr::JsxElement {
-            props, children, ..
+            tag,
+            tag_span,
+            close_tag_span,
+            props,
+            children,
+            ..
         } => {
+            // A PascalCase tag is a reference to its component binding. Count BOTH the opening and
+            // closing tag so find-references lists them and rename rewrites both (renaming only the
+            // open tag would leave `<Bar></Foo>`). maybe_push validates each via definition_span.
+            if tag.chars().next().is_some_and(|c| c.is_uppercase()) {
+                maybe_push(tag_span, tag, out);
+                if let Some(cs) = close_tag_span {
+                    maybe_push(cs, tag, out);
+                }
+            }
             for p in props {
                 match p {
                     tishlang_ast::JsxProp::Attr { value, .. } => {
@@ -3554,6 +4000,280 @@ mod tests {
         assert_eq!(u[0].kind, UnusedBindingKind::Import);
     }
 
+    #[test]
+    fn import_used_in_exported_fn_body_not_unused() {
+        // Regression: a binding used only inside an `export fn` body was wrongly flagged unused
+        // because refs_stmt did not descend into Statement::Export.
+        let src = "import { publicUser } from \"./m\"\nexport fn toUserPublic(store, u) {\n  let pub = publicUser(u)\n  return pub\n}\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "publicUser is used in the exported fn; u={u:?}");
+    }
+
+    #[test]
+    fn import_used_in_export_default_not_unused() {
+        let src = "import { p } from \"./m\"\nexport default p(1)\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "p is used in export default; u={u:?}");
+    }
+
+    #[test]
+    fn import_used_in_exported_let_init_not_unused() {
+        let src = "import { p } from \"./m\"\nexport let x = p(1)\nx\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "p is used in the exported let init; u={u:?}");
+    }
+
+    #[test]
+    fn genuinely_unused_import_still_flagged_with_export_present() {
+        // Guard against the fix over-counting: a truly-unused import is still reported even when an
+        // exported declaration is present in the module.
+        let src = "import { used, dead } from \"./m\"\nexport fn f() {\n  return used()\n}\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert_eq!(u.len(), 1, "only `dead` is unused; u={u:?}");
+        assert_eq!(u[0].name.as_ref(), "dead");
+        assert_eq!(u[0].kind, UnusedBindingKind::Import);
+    }
+
+    #[test]
+    fn reference_spans_include_uses_in_exported_fn_body() {
+        // Directly exercises the fixed walker (also backs find-references / rename).
+        let src = "import { publicUser } from \"./m\"\nexport fn f(u) {\n  return publicUser(u)\n}\n";
+        let program = parse(src).expect("parse");
+        let def = tishlang_ast::Span {
+            start: (1, 10),
+            end: (1, 20),
+        };
+        let refs = reference_spans_for_def(&program, src, "publicUser", def);
+        assert_eq!(refs.len(), 2, "def + one use in exported body; refs={refs:?}");
+        assert!(refs.contains(&def));
+    }
+
+    #[test]
+    fn import_used_only_in_fn_param_default_not_unused() {
+        // A name referenced only inside a parameter default was wrongly flagged unused because the
+        // resolve walkers never descended into `default` expressions.
+        let src = "import { base } from \"./m\"\nexport fn f(a = base(1)) {\n  return a\n}\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "base is used in the param default; u={u:?}");
+    }
+
+    #[test]
+    fn import_used_only_in_arrow_param_default_not_unused() {
+        let src = "import { fallback } from \"./m\"\nlet make = (x = fallback) => x\nmake()\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "fallback is used in the arrow param default; u={u:?}");
+    }
+
+    #[test]
+    fn gotodef_resolves_name_used_in_param_default() {
+        let src = "import { base } from \"./m\"\nfn f(a = base(1)) {\n  return a\n}\n";
+        let program = parse(src).expect("parse");
+        // cursor on `base` inside the default (0-indexed line 1, char 9)
+        let def = definition_span(&program, src, 1, 9);
+        assert_eq!(def, Some(tishlang_ast::Span { start: (1, 10), end: (1, 14) }), "def={def:?}");
+    }
+
+    #[test]
+    fn gotodef_resolves_rest_param_body_use() {
+        let src = "fn f(...rest) {\n  return rest\n}\n";
+        let program = parse(src).expect("parse");
+        // cursor on `rest` in the body (0-indexed line 1, char 9) -> the rest-param binding
+        let def = definition_span(&program, src, 1, 9);
+        assert_eq!(def, Some(tishlang_ast::Span { start: (1, 9), end: (1, 13) }), "def={def:?}");
+    }
+
+    #[test]
+    fn name_at_cursor_finds_rest_param_decl() {
+        let src = "fn f(...rest) {\n  return rest\n}\n";
+        let program = parse(src).expect("parse");
+        // cursor on the `...rest` declaration name (0-indexed line 0, char 8)
+        let nu = name_at_cursor(&program, src, 0, 8).expect("name under cursor");
+        assert_eq!(nu.name.as_ref(), "rest");
+    }
+
+    #[test]
+    fn param_default_referencing_sibling_param_resolves_to_param_not_outer() {
+        // `a` exists both as an outer binding (line 0) and a param (line 1). The default `b = a`
+        // must resolve to the PARAM, not the outer — i.e. defaults are checked with params in scope.
+        let src = "let a = 1\nfn f(a, b = a) {\n  return b\n}\nf(2)\n";
+        let program = parse(src).expect("parse");
+        // cursor on `a` inside `b = a` (0-indexed line 1, char 12)
+        let def = definition_span(&program, src, 1, 12).expect("resolved");
+        assert_eq!(def.start.0, 2, "should resolve to the param on line 2 (1-indexed); def={def:?}");
+    }
+
+    #[test]
+    fn references_include_both_param_default_and_body_uses() {
+        let src = "fn helper() { 1 }\nfn f(b = helper()) {\n  return helper()\n}\nf()\n";
+        let program = parse(src).expect("parse");
+        let def = tishlang_ast::Span { start: (1, 4), end: (1, 10) };
+        let refs = reference_spans_for_def(&program, src, "helper", def);
+        // def + use in param default + use in body
+        assert_eq!(refs.len(), 3, "decl + default-use + body-use; refs={refs:?}");
+    }
+
+    #[test]
+    fn unresolved_name_in_param_default_reported() {
+        let src = "fn f(a = mispelt) {\n  return a\n}\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unresolved_identifiers(&program);
+        assert_eq!(u.len(), 1, "u={u:?}");
+        assert_eq!(u[0].name.as_ref(), "mispelt");
+    }
+
+    #[test]
+    fn import_used_only_in_declare_fn_default_not_unused() {
+        let src = "import { DEF } from \"./m\"\ndeclare fn connect(port = DEF): void\nconnect()\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        // The import used in the declare-fn param default must not be reported unused.
+        // (Unrelated pre-existing declare-fn quirks may flag `connect`/`port`; not asserted here.)
+        assert!(
+            !u.iter().any(|b| b.name.as_ref() == "DEF"),
+            "DEF is used in the declare-fn param default; u={u:?}"
+        );
+    }
+
+    #[test]
+    fn forward_reference_to_later_fn_not_unresolved() {
+        let src = "fn caller() { return helper() }\nfn helper() { return 42 }\ncaller()\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unresolved_identifiers(&program);
+        assert!(u.is_empty(), "helper is declared later but referenced (hoisted); u={u:?}");
+    }
+
+    #[test]
+    fn mutual_recursion_not_unresolved_or_unused() {
+        let src = "fn even(n) { if (n == 0) { return true } return odd(n - 1) }\nfn odd(n) { if (n == 0) { return false } return even(n - 1) }\neven(10)\n";
+        let program = parse(src).expect("parse");
+        assert!(
+            collect_unresolved_identifiers(&program).is_empty(),
+            "mutual recursion should resolve"
+        );
+        let unused = collect_unused_bindings(&program, src);
+        assert!(unused.is_empty(), "both fns are used; unused={unused:?}");
+    }
+
+    #[test]
+    fn gotodef_resolves_forward_fn_reference() {
+        let src = "fn caller() { return helper() }\nfn helper() { return 42 }\n";
+        let program = parse(src).expect("parse");
+        // cursor on `helper` inside caller's body (0-indexed line 0, char 21)
+        let def = definition_span(&program, src, 0, 21).expect("resolves");
+        assert_eq!(def.start.0, 2, "should resolve to helper decl on line 2; def={def:?}");
+    }
+
+    #[test]
+    fn genuinely_undefined_still_unresolved_with_hoisting() {
+        let src = "fn f() { return nope() }\nf()\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unresolved_identifiers(&program);
+        assert_eq!(u.len(), 1, "nope is undefined; u={u:?}");
+        assert_eq!(u[0].name.as_ref(), "nope");
+    }
+
+    #[test]
+    fn declare_fn_name_and_params_not_unused() {
+        // Ambient declare-fn: the (called) name and its params must not be flagged unused.
+        let src = "declare fn connect(port): void\nconnect()\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(u.is_empty(), "declare-fn name + ambient param must not be unused; u={u:?}");
+        // and the call resolves (hoisted declare-fn name)
+        assert!(collect_unresolved_identifiers(&program).is_empty(), "connect() should resolve");
+    }
+
+    #[test]
+    fn runtime_globals_not_unresolved() {
+        // Core interpreter globals must never be flagged as unresolved-name in the editor.
+        let src = "let _ = [Number, Symbol, Error, TypeError, RangeError, SyntaxError, Promise, fetch, fetchAll, serve, htmlEscape, console, Math, JSON, Object, Array, String, Boolean, Date, RegExp, setTimeout]\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unresolved_identifiers(&program);
+        assert!(u.is_empty(), "no runtime global should be unresolved; u={u:?}");
+    }
+
+    #[test]
+    fn jsx_component_tag_resolves_and_is_referenced() {
+        // `fn Foo` used as a component. go-to-def on the tag, find-references over both tags.
+        let src = "fn Foo() {}\nlet el = <Foo></Foo>\nel\n";
+        let program = parse(src).expect("parse");
+        // go-to-def on the opening `<Foo` (0-idx line 1, char 10) → the `fn Foo` decl (line 2, 1-idx).
+        let open = definition_span(&program, src, 1, 10).expect("open tag resolves");
+        assert_eq!(open.start, (1, 4), "resolves to fn Foo; got {open:?}");
+        // and on the closing `</Foo` (char 16).
+        let close = definition_span(&program, src, 1, 16).expect("close tag resolves");
+        assert_eq!(close.start, (1, 4), "close tag resolves to fn Foo; got {close:?}");
+        // find-references: the def + the opening tag + the closing tag.
+        let def = tishlang_ast::Span { start: (1, 4), end: (1, 7) };
+        let refs = reference_spans_for_def(&program, src, "Foo", def);
+        assert_eq!(refs.len(), 3, "def + open tag + close tag; refs={refs:?}");
+    }
+
+    #[test]
+    fn jsx_component_import_used_as_tag_not_unused() {
+        let src = "import { Foo } from \"./c\"\nlet el = <Foo/>\nel\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(
+            !u.iter().any(|b| b.name.as_ref() == "Foo"),
+            "Foo is used as a component tag; u={u:?}"
+        );
+    }
+
+    #[test]
+    fn jsx_nested_component_tag_counted() {
+        let src = "import { Row } from \"./c\"\nlet el = <div><Row/></div>\nel\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(
+            !u.iter().any(|b| b.name.as_ref() == "Row"),
+            "Row is used as a nested component; u={u:?}"
+        );
+    }
+
+    #[test]
+    fn lowercase_jsx_tag_does_not_mark_binding_used() {
+        // Lowercase tags lower to string literals, not references — a same-named binding stays unused.
+        let src = "let div = 1\nlet el = <div></div>\nel\n";
+        let program = parse(src).expect("parse");
+        let u = collect_unused_bindings(&program, src);
+        assert!(
+            u.iter().any(|b| b.name.as_ref() == "div"),
+            "lowercase div binding is genuinely unused; u={u:?}"
+        );
+    }
+
+    #[test]
+    fn collect_unused_bindings_handles_large_files() {
+        // A long chain of mutually-referencing functions exercises the per-binding reference scan at
+        // scale. Under the old per-binding/per-identifier definition_span re-resolution this was
+        // ~O(N^3) and froze (~1.4s at 300 lines); with the memo it is fast. Also a correctness check:
+        // every function is reachable, so none is unused.
+        let n = 300;
+        let mut src = String::new();
+        for i in 0..n {
+            if i + 1 < n {
+                src.push_str(&format!("fn f{i}() {{ return f{}() }}\n", i + 1));
+            } else {
+                src.push_str(&format!("fn f{i}() {{ return 0 }}\n"));
+            }
+        }
+        src.push_str("f0()\n");
+        let program = parse(&src).expect("parse");
+        let u = collect_unused_bindings(&program, &src);
+        assert!(
+            u.is_empty(),
+            "all chained fns are reachable; unused={:?}",
+            u.iter().map(|b| b.name.as_ref()).collect::<Vec<_>>()
+        );
+    }
+
     #[test]
     fn unused_let_underscore_ignored() {
         let src = "let _x = 1\n";