@tishlang/tish 2.2.5 → 2.8.0

package/crates/tish_resolve/src/lib.rs

@@ -81,6 +81,15 @@ thread_local! {
     /// no behavior change.
     static REFERENCED_DEFS: std::cell::RefCell<Option<std::collections::HashSet<(usize, usize)>>> =
         const { std::cell::RefCell::new(None) };
+
+    /// Stack of definition-span starts of the functions whose bodies we are currently inside. A use
+    /// that resolves to one of these is a SELF-reference (e.g. `fn a() { return a() }`) — recursion,
+    /// not an external use — so it must not mark the binding "referenced" for the unused check, or a
+    /// function reachable only via its own recursion would never be flagged dead (#150). Only
+    /// consulted while `REFERENCED_DEFS` is active; find-references / go-to-definition (which want the
+    /// recursive call) use a different path and are unaffected.
+    static CURRENT_FN_DEFS: std::cell::RefCell<Vec<(usize, usize)>> =
+        const { std::cell::RefCell::new(Vec::new()) };
 }
 
 /// One scope-aware resolution pass: the set of definition span *starts* that at least one identifier
@@ -92,6 +101,9 @@ fn collect_referenced_def_spans(program: &Program) -> std::collections::HashSet<
     impl Drop for Guard {
         fn drop(&mut self) {
             REFERENCED_DEFS.with(|r| *r.borrow_mut() = None);
+            // Defensive: the FunDecl walk push/pops this in balanced pairs, but clear it here too so
+            // a panic mid-walk can't leave a stale enclosing-fn span for the next collection.
+            CURRENT_FN_DEFS.with(|s| s.borrow_mut().clear());
         }
     }
     let _g = Guard;
@@ -457,7 +469,7 @@ fn collect_expr(
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => {
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => {
                         collect_expr(e, source, lsp_line, lsp_char, best)
                     }
                     tishlang_ast::ObjectProp::Spread(e) => {
@@ -729,7 +741,7 @@ fn member_chain_collect_expr(
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => {
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => {
                         member_chain_collect_expr(e, source, lsp_line, lsp_char, best)
                     }
                     tishlang_ast::ObjectProp::Spread(e) => {
@@ -1213,7 +1225,7 @@ fn walk_expr_resolve(
         Expr::Object { props, .. } => {
             for p in props {
                 let e = match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => e,
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => e,
                     tishlang_ast::ObjectProp::Spread(e) => e,
                 };
                 if let Some(s) = walk_expr_resolve(e, scopes, target) {
@@ -1730,11 +1742,17 @@ fn record_unresolved(
         // 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);
-                }
-            });
+            // A use that resolves to a function we're currently inside is a self-recursive call,
+            // not an external use — skip it so a function reachable only via its own recursion is
+            // still reported unused (#150).
+            let is_self_ref = CURRENT_FN_DEFS.with(|s| s.borrow().contains(&def.start));
+            if !is_self_ref {
+                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()) {
@@ -1747,12 +1765,32 @@ fn record_unresolved(
     }
 }
 
+/// Like [`record_unresolved`] for an assignment TARGET: still flags an unresolved name (writing to
+/// an undeclared variable is an error), but does NOT mark a resolved def as *referenced*. A pure
+/// write — and, like ESLint's `no-unused-vars`, a read-modify-write (`+=`/`++`/`||=`) — is not a
+/// "use", so a binding that is only ever written gets reported as unused. Reads elsewhere (incl. the
+/// RHS, e.g. `n = n + 1`) still go through `record_unresolved` and keep the binding live. (#149)
+fn record_write(
+    scopes: &ScopeStack,
+    name: &Arc<str>,
+    span: tishlang_ast::Span,
+    out: &mut Vec<UnresolvedIdentifier>,
+) {
+    if scopes.resolve(name.as_ref()).is_none() && !is_runtime_global_ident(name.as_ref()) {
+        out.push(UnresolvedIdentifier {
+            name: name.clone(),
+            span,
+        });
+    }
+}
+
 fn check_unresolved_expr(expr: &Expr, scopes: &ScopeStack, out: &mut Vec<UnresolvedIdentifier>) {
     match expr {
         Expr::Ident { name, span } => record_unresolved(scopes, name, *span, out),
         Expr::Assign { name, span, value } => {
+            // Target is a WRITE (not a read) for unused detection; the RHS is read normally.
             let sp = synthetic_name_span(span.start, name.as_ref());
-            record_unresolved(scopes, name, sp, out);
+            record_write(scopes, name, sp, out);
             check_unresolved_expr(value, scopes, out);
         }
         Expr::CompoundAssign {
@@ -1761,17 +1799,18 @@ fn check_unresolved_expr(expr: &Expr, scopes: &ScopeStack, out: &mut Vec<Unresol
         | Expr::LogicalAssign {
             name, span, value, ..
         } => {
+            // Read-modify-write: ESLint counts the target as a write, not a use. RHS is read.
             let sp = synthetic_name_span(span.start, name.as_ref());
-            record_unresolved(scopes, name, sp, out);
+            record_write(scopes, name, sp, out);
             check_unresolved_expr(value, scopes, out);
         }
         Expr::PostfixInc { name, span } | Expr::PostfixDec { name, span } => {
             let sp = synthetic_name_span(span.start, name.as_ref());
-            record_unresolved(scopes, name, sp, out);
+            record_write(scopes, name, sp, out);
         }
         Expr::PrefixInc { name, span } | Expr::PrefixDec { name, span } => {
             let sp = synthetic_name_span(span.start, name.as_ref());
-            record_unresolved(scopes, name, sp, out);
+            record_write(scopes, name, sp, out);
         }
         Expr::Binary { left, right, .. } => {
             check_unresolved_expr(left, scopes, out);
@@ -1834,7 +1873,7 @@ fn check_unresolved_expr(expr: &Expr, scopes: &ScopeStack, out: &mut Vec<Unresol
         Expr::Object { props, .. } => {
             for p in props {
                 let e = match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => e,
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => e,
                     tishlang_ast::ObjectProp::Spread(e) => e,
                 };
                 check_unresolved_expr(e, scopes, out);
@@ -2033,7 +2072,13 @@ fn check_unresolved_stmt(
                     check_unresolved_expr(e, scopes, out);
                 }
             }
+            // Mark this function as "currently inside" so a recursive self-call in the body isn't
+            // counted as an external use for the unused-binding check (#150).
+            CURRENT_FN_DEFS.with(|s| s.borrow_mut().push(name_span.start));
             check_unresolved_stmt(body, scopes, out);
+            CURRENT_FN_DEFS.with(|s| {
+                s.borrow_mut().pop();
+            });
             scopes.pop();
             scopes.define(name.as_ref(), *name_span);
         }
@@ -2324,7 +2369,7 @@ fn enumerate_expr(expr: &Expr, exported: bool, out: &mut Vec<BindingSite>) {
         Expr::Object { props, .. } => {
             for p in props {
                 let e = match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => e,
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => e,
                     tishlang_ast::ObjectProp::Spread(e) => e,
                 };
                 enumerate_expr(e, exported, out);
@@ -2829,7 +2874,7 @@ fn jsx_tags_expr(e: &Expr, out: &mut std::collections::HashSet<Arc<str>>) {
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e)
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _)
                     | tishlang_ast::ObjectProp::Spread(e) => jsx_tags_expr(e, out),
                 }
             }
@@ -2877,6 +2922,19 @@ fn jsx_tags_expr(e: &Expr, out: &mut std::collections::HashSet<Arc<str>>) {
     }
 }
 
+/// Names referenced in a TYPE position — every `Simple(name)` use in a type annotation (param /
+/// var / return types, alias bodies, nested object/array/union/fn types). A binding (a type-only
+/// import or a type alias) used *only* as a type would otherwise be reported unused (#139), since
+/// the value-resolution walk never sees annotations. Name-based and intentionally conservative,
+/// mirroring the JSX-tag set.
+fn type_reference_names(program: &Program) -> std::collections::HashSet<Arc<str>> {
+    let mut occ: Vec<TypeOcc> = Vec::new();
+    for s in &program.statements {
+        tref_stmt(s, &mut occ);
+    }
+    occ.into_iter().filter(|o| !o.is_decl).map(|o| o.name).collect()
+}
+
 /// 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> {
@@ -2888,6 +2946,9 @@ pub fn collect_unused_bindings(program: &Program, _source: &str) -> Vec<UnusedBi
     // 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);
+    // A binding referenced only in a type annotation (`: Foo`) is used; the value walk can't see
+    // type positions, so consult the type-reference names to avoid a false "unused" report (#139).
+    let type_refs = type_reference_names(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.
@@ -2900,6 +2961,9 @@ pub fn collect_unused_bindings(program: &Program, _source: &str) -> Vec<UnusedBi
         if jsx_tags.contains(&site.name) {
             continue;
         }
+        if type_refs.contains(&site.name) {
+            continue;
+        }
         if !referenced.contains(&site.span.start) {
             out.push(UnusedBinding {
                 name: site.name,
@@ -3219,7 +3283,7 @@ fn walk_expr_completion(
         Expr::Object { props, .. } => {
             for p in props {
                 let e = match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => e,
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => e,
                     tishlang_ast::ObjectProp::Spread(e) => e,
                 };
                 walk_expr_completion(e, source, lsp_line, lsp_char, stack, best);
@@ -3570,6 +3634,358 @@ pub fn shallow_module_bindings(program: &Program) -> Vec<(Arc<str>, tishlang_ast
 }
 
 /// All spans (definition + uses) that resolve to `def_span` for `name`.
+// ---- Type-alias rename (#131) ---------------------------------------------------------------
+// Type names live in a namespace separate from value bindings, so the value resolver
+// (`definition_span` / `reference_spans_for_def`) never sees `: T` annotation uses. These walkers
+// gather every type-name occurrence — the alias declaration plus each span-carrying
+// `TypeAnnotation::Simple` reference in any annotation — so renaming a type alias edits the
+// declaration and all its uses together (previously only the declaration was edited, silently
+// breaking the program).
+
+struct TypeOcc {
+    name: Arc<str>,
+    span: tishlang_ast::Span,
+    is_decl: bool,
+}
+
+fn tref_ann(ann: &tishlang_ast::TypeAnnotation, out: &mut Vec<TypeOcc>) {
+    use tishlang_ast::TypeAnnotation as T;
+    match ann {
+        T::Simple(name, span) => out.push(TypeOcc {
+            name: name.clone(),
+            span: *span,
+            is_decl: false,
+        }),
+        T::Array(inner) => tref_ann(inner, out),
+        T::Object(fields) => {
+            for (_, t) in fields {
+                tref_ann(t, out);
+            }
+        }
+        T::Function { params, returns } => {
+            for p in params {
+                tref_ann(p, out);
+            }
+            tref_ann(returns, out);
+        }
+        T::Union(ts) | T::Tuple(ts) | T::Intersection(ts) => {
+            for t in ts {
+                tref_ann(t, out);
+            }
+        }
+        T::Literal(_) => {}
+    }
+}
+
+fn tref_typed_param(tp: &TypedParam, out: &mut Vec<TypeOcc>) {
+    if let Some(t) = &tp.type_ann {
+        tref_ann(t, out);
+    }
+    if let Some(d) = &tp.default {
+        tref_expr(d, out);
+    }
+}
+
+fn tref_param(p: &FunParam, out: &mut Vec<TypeOcc>) {
+    match p {
+        FunParam::Simple(tp) => tref_typed_param(tp, out),
+        FunParam::Destructure {
+            type_ann, default, ..
+        } => {
+            if let Some(t) = type_ann {
+                tref_ann(t, out);
+            }
+            if let Some(d) = default {
+                tref_expr(d, out);
+            }
+        }
+    }
+}
+
+fn tref_arrow_body(body: &ArrowBody, out: &mut Vec<TypeOcc>) {
+    match body {
+        ArrowBody::Expr(e) => tref_expr(e, out),
+        ArrowBody::Block(s) => tref_stmt(s, out),
+    }
+}
+
+fn tref_expr(expr: &Expr, out: &mut Vec<TypeOcc>) {
+    match expr {
+        Expr::ArrowFunction { params, body, .. } => {
+            for p in params {
+                tref_param(p, out);
+            }
+            tref_arrow_body(body, out);
+        }
+        Expr::Binary { left, right, .. } | Expr::NullishCoalesce { left, right, .. } => {
+            tref_expr(left, out);
+            tref_expr(right, out);
+        }
+        Expr::Unary { operand, .. }
+        | Expr::TypeOf { operand, .. }
+        | Expr::Await { operand, .. } => tref_expr(operand, out),
+        Expr::Delete { target, .. } => tref_expr(target, out),
+        Expr::Call { callee, args, .. } | Expr::New { callee, args, .. } => {
+            tref_expr(callee, out);
+            for a in args {
+                match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => tref_expr(e, out),
+                }
+            }
+        }
+        Expr::Member { object, .. } => tref_expr(object, out),
+        Expr::Index { object, index, .. } => {
+            tref_expr(object, out);
+            tref_expr(index, out);
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            tref_expr(cond, out);
+            tref_expr(then_branch, out);
+            tref_expr(else_branch, out);
+        }
+        Expr::Array { elements, .. } => {
+            for el in elements {
+                match el {
+                    tishlang_ast::ArrayElement::Expr(e)
+                    | tishlang_ast::ArrayElement::Spread(e) => tref_expr(e, out),
+                }
+            }
+        }
+        Expr::Object { props, .. } => {
+            for p in props {
+                match p {
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _)
+                    | tishlang_ast::ObjectProp::Spread(e) => tref_expr(e, out),
+                }
+            }
+        }
+        Expr::Assign { value, .. }
+        | Expr::CompoundAssign { value, .. }
+        | Expr::LogicalAssign { value, .. } => tref_expr(value, out),
+        Expr::MemberAssign { object, value, .. } => {
+            tref_expr(object, out);
+            tref_expr(value, out);
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            tref_expr(object, out);
+            tref_expr(index, out);
+            tref_expr(value, out);
+        }
+        Expr::TemplateLiteral { exprs, .. } => {
+            for e in exprs {
+                tref_expr(e, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn tref_stmt(stmt: &Statement, out: &mut Vec<TypeOcc>) {
+    match stmt {
+        Statement::TypeAlias {
+            name,
+            name_span,
+            ty,
+            ..
+        } => {
+            out.push(TypeOcc {
+                name: name.clone(),
+                span: *name_span,
+                is_decl: true,
+            });
+            tref_ann(ty, out);
+        }
+        Statement::VarDecl { type_ann, init, .. } => {
+            if let Some(t) = type_ann {
+                tref_ann(t, out);
+            }
+            if let Some(e) = init {
+                tref_expr(e, out);
+            }
+        }
+        Statement::VarDeclDestructure { init, .. } => tref_expr(init, out),
+        Statement::DeclareVar { type_ann, .. } => {
+            if let Some(t) = type_ann {
+                tref_ann(t, out);
+            }
+        }
+        Statement::FunDecl {
+            params,
+            rest_param,
+            return_type,
+            body,
+            ..
+        } => {
+            for p in params {
+                tref_param(p, out);
+            }
+            if let Some(rp) = rest_param {
+                tref_typed_param(rp, out);
+            }
+            if let Some(t) = return_type {
+                tref_ann(t, out);
+            }
+            tref_stmt(body, out);
+        }
+        Statement::DeclareFun {
+            params,
+            rest_param,
+            return_type,
+            ..
+        } => {
+            for p in params {
+                tref_param(p, out);
+            }
+            if let Some(rp) = rest_param {
+                tref_typed_param(rp, out);
+            }
+            if let Some(t) = return_type {
+                tref_ann(t, out);
+            }
+        }
+        Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+            for s in statements {
+                tref_stmt(s, out);
+            }
+        }
+        Statement::ExprStmt { expr, .. } => tref_expr(expr, out),
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            tref_expr(cond, out);
+            tref_stmt(then_branch, out);
+            if let Some(e) = else_branch {
+                tref_stmt(e, out);
+            }
+        }
+        Statement::While { cond, body, .. } => {
+            tref_expr(cond, out);
+            tref_stmt(body, out);
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
+            if let Some(i) = init {
+                tref_stmt(i, out);
+            }
+            if let Some(c) = cond {
+                tref_expr(c, out);
+            }
+            if let Some(u) = update {
+                tref_expr(u, out);
+            }
+            tref_stmt(body, out);
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            tref_expr(iterable, out);
+            tref_stmt(body, out);
+        }
+        Statement::DoWhile { body, cond, .. } => {
+            tref_stmt(body, out);
+            tref_expr(cond, out);
+        }
+        Statement::Return { value, .. } => {
+            if let Some(e) = value {
+                tref_expr(e, out);
+            }
+        }
+        Statement::Throw { value, .. } => tref_expr(value, out),
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
+            tref_expr(expr, out);
+            for (c, body) in cases {
+                if let Some(c) = c {
+                    tref_expr(c, out);
+                }
+                for s in body {
+                    tref_stmt(s, out);
+                }
+            }
+            if let Some(body) = default_body {
+                for s in body {
+                    tref_stmt(s, out);
+                }
+            }
+        }
+        Statement::Try {
+            body,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            tref_stmt(body, out);
+            if let Some(c) = catch_body {
+                tref_stmt(c, out);
+            }
+            if let Some(f) = finally_body {
+                tref_stmt(f, out);
+            }
+        }
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => tref_stmt(inner, out),
+            ExportDeclaration::Default(e) => tref_expr(e, out),
+        },
+        _ => {}
+    }
+}
+
+/// If the cursor sits on a type-alias declaration name or on a `: T` type-reference use, returns
+/// every source span that must be renamed together (the declaration plus all annotation uses).
+/// Returns `None` when the cursor is not on a user-declared type alias, so callers fall back to
+/// value-binding rename. Fixes the silent breakage where renaming a `type T` left every `: T`
+/// annotation stale (type names are in a namespace the value resolver does not see).
+pub fn type_alias_rename_spans(
+    program: &Program,
+    source: &str,
+    lsp_line: u32,
+    lsp_character: u32,
+) -> Option<Vec<tishlang_ast::Span>> {
+    let mut occ: Vec<TypeOcc> = Vec::new();
+    for s in &program.statements {
+        tref_stmt(s, &mut occ);
+    }
+    // The type name whose declaration or use span contains the cursor.
+    let target = occ
+        .iter()
+        .find(|o| pos::span_contains_lsp_position(source, &o.span, lsp_line, lsp_character))?
+        .name
+        .clone();
+    // Only rename user-declared aliases — never a builtin (`number`, `string`, …) used in an
+    // annotation, which has no declaration to keep in sync.
+    if !occ.iter().any(|o| o.is_decl && o.name == target) {
+        return None;
+    }
+    let mut spans: Vec<tishlang_ast::Span> = occ
+        .iter()
+        .filter(|o| o.name == target)
+        .map(|o| o.span)
+        .collect();
+    spans.sort_by_key(|s| (s.start.0, s.start.1, s.end.0, s.end.1));
+    spans.dedup();
+    Some(spans)
+}
+
 pub fn reference_spans_for_def(
     program: &Program,
     source: &str,
@@ -3807,7 +4223,7 @@ fn refs_expr(
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e) => {
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _) => {
                         refs_expr(e, program, source, name, def_span, out)
                     }
                     tishlang_ast::ObjectProp::Spread(e) => {
@@ -3965,6 +4381,20 @@ mod tests {
         assert!(names.iter().any(|n| n.as_ref() == "bar"));
     }
 
+    // #158: on the line AFTER a function's closing brace, completion must not leak the function's
+    // params or inner locals (the body Block span used to overrun onto that line). The top-level
+    // function name is still in scope.
+    #[test]
+    fn completion_does_not_leak_past_function_brace() {
+        let src = "fn f(paramA, paramB) {\n  let secret = 1\n}\nlet after = 0\n";
+        let program = parse(src).expect("parse");
+        let names = completion_value_names_at_cursor(&program, src, 3, 0); // start of `let after`
+        let has = |n: &str| names.iter().any(|x| x.as_ref() == n);
+        assert!(!has("paramA") && !has("paramB"), "params leaked past `}}`: {names:?}");
+        assert!(!has("secret"), "inner local leaked past `}}`: {names:?}");
+        assert!(has("f"), "top-level fn must stay in scope: {names:?}");
+    }
+
     #[test]
     fn unresolved_unknown_ident() {
         let src = "let x = nope\n";
@@ -4038,6 +4468,74 @@ mod tests {
         assert_eq!(u[0].kind, UnusedBindingKind::Import);
     }
 
+    // #149: a binding that is only ever WRITTEN (never read) is unused (matches ESLint).
+    #[test]
+    fn write_only_variables_are_flagged_unused() {
+        for (src, who) in [
+            ("let n = 0\nn += 5\n", "n"),     // read-modify-write
+            ("let w = 0\nw = 7\n", "w"),       // plain write
+            ("let p = 0\np++\n", "p"),         // postfix inc
+            ("let q = 0\n++q\n", "q"),         // prefix inc
+        ] {
+            let program = parse(src).expect("parse");
+            let u = collect_unused_bindings(&program, src);
+            assert!(
+                u.iter().any(|b| b.name.as_ref() == who
+                    && b.kind == UnusedBindingKind::Variable),
+                "{who} is write-only and should be flagged unused; src={src:?} u={u:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn variables_read_anywhere_are_not_flagged() {
+        // A read on the RHS of its own assignment, or a bare use, keeps the binding live.
+        for src in [
+            "let count = 0\ncount = count + 1\ncount\n", // read in RHS + bare use
+            "let acc = 0\nacc += 1\nacc\n",              // compound write + later read
+            "let x = 1\nx\n",                            // plain read (control)
+        ] {
+            let program = parse(src).expect("parse");
+            let u = collect_unused_bindings(&program, src);
+            assert!(u.is_empty(), "no unused expected; src={src:?} u={u:?}");
+        }
+    }
+
+    // #150: a function reachable only via its own recursion is dead code and should be flagged.
+    #[test]
+    fn self_recursive_only_function_is_flagged_unused() {
+        for src in ["fn a() { return a() }\n", "fn loop_(n) { return loop_(n - 1) }\n"] {
+            let program = parse(src).expect("parse");
+            let u = collect_unused_bindings(&program, src);
+            assert_eq!(u.len(), 1, "self-recursive-only fn is unused; src={src:?} u={u:?}");
+        }
+    }
+
+    #[test]
+    fn externally_called_or_mutually_recursive_functions_not_flagged() {
+        // External call keeps it live; mutual recursion (each refers to the OTHER) keeps both live —
+        // only pure SELF-reference is excluded.
+        for src in [
+            "fn c() { return 1 }\nc()\n",
+            "fn p() { return q() }\nfn q() { return p() }\np()\n",
+        ] {
+            let program = parse(src).expect("parse");
+            let u = collect_unused_bindings(&program, src);
+            assert!(u.is_empty(), "no unused expected; src={src:?} u={u:?}");
+        }
+    }
+
+    #[test]
+    fn write_to_undeclared_still_unresolved() {
+        // record_write must keep flagging a write to an undeclared name (not silently swallow it).
+        let program = parse("undeclared = 5\n").expect("parse");
+        let unresolved = collect_unresolved_identifiers(&program);
+        assert!(
+            unresolved.iter().any(|u| u.name.as_ref() == "undeclared"),
+            "writing to an undeclared variable is still unresolved; got={unresolved:?}"
+        );
+    }
+
     #[test]
     fn reference_spans_include_uses_in_exported_fn_body() {
         // Directly exercises the fixed walker (also backs find-references / rename).
@@ -4329,4 +4827,56 @@ mod tests {
         assert_eq!(ch.members[0].as_ref(), "b");
         assert_eq!(ch.members[1].as_ref(), "c");
     }
+
+    #[test]
+    fn type_alias_rename_collects_decl_and_all_annotation_uses() {
+        // #131: renaming a type alias must edit the declaration AND every `: T` annotation, or the
+        // program silently breaks. Type names are in a namespace the value resolver doesn't see.
+        let src = "type T = number\nlet a: T = 1\nfn f(x: T): T { return x }\n";
+        let program = parse(src).expect("parse");
+        fn span_text(src: &str, sp: &tishlang_ast::Span) -> String {
+            let lines: Vec<&str> = src.lines().collect();
+            let (sl, sc) = sp.start;
+            let (_el, ec) = sp.end;
+            lines[sl - 1].chars().skip(sc - 1).take(ec - sc).collect()
+        }
+        // Cursor on the declaration name `T` (0-indexed line 0, char 5).
+        let spans = type_alias_rename_spans(&program, src, 0, 5).expect("type rename spans");
+        assert_eq!(spans.len(), 4, "decl + let-ann + param-ann + return-ann; spans={spans:?}");
+        for sp in &spans {
+            assert_eq!(span_text(src, sp), "T", "every rename span covers the `T` token; {sp:?}");
+        }
+        // Initiating from a `: T` use also works (the param annotation, line 2 char 8).
+        let from_use = type_alias_rename_spans(&program, src, 2, 8).expect("rename from use");
+        assert_eq!(from_use.len(), 4, "same set whether initiated from decl or use");
+        // A builtin used in an annotation (`number`, line 0 char 9) is not a user alias -> None.
+        assert!(
+            type_alias_rename_spans(&program, src, 0, 9).is_none(),
+            "builtin `number` has no declaration to rename"
+        );
+    }
+}
+
+#[cfg(test)]
+mod type_ref_unused_tests {
+    use super::*;
+    fn unused(src: &str) -> Vec<String> {
+        collect_unused_bindings(&tishlang_parser::parse(src).expect("parse"), src)
+            .iter().map(|b| b.name.to_string()).collect()
+    }
+    // #139: an import used only in a type annotation must not be flagged unused.
+    #[test] fn type_only_import_not_unused() {
+        let u = unused("import { Foo } from \"./m\"\nlet x: Foo = bar()\nx\n");
+        assert!(!u.contains(&"Foo".to_string()), "type-only import Foo wrongly unused; u={u:?}");
+    }
+    // #139: a type alias referenced only in an annotation must not be flagged unused.
+    #[test] fn type_alias_used_in_annotation_not_unused() {
+        let u = unused("type T = number\nfn f(x: T) { return x }\nf(1)\n");
+        assert!(!u.contains(&"T".to_string()), "type alias T wrongly unused; u={u:?}");
+    }
+    // guard: a genuinely-unused import is still reported.
+    #[test] fn genuinely_unused_import_still_flagged() {
+        let u = unused("import { Dead } from \"./m\"\nlet y = 1\ny\n");
+        assert!(u.contains(&"Dead".to_string()), "Dead should be unused; u={u:?}");
+    }
 }