@tishlang/tish 2.2.7 → 2.9.0

package/crates/tish_opt/src/lib.rs

@@ -429,8 +429,8 @@ fn optimize_expr(expr: &Expr) -> Expr {
             props: props
                 .iter()
                 .map(|p| match p {
-                    tishlang_ast::ObjectProp::KeyValue(k, v) => {
-                        tishlang_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v))
+                    tishlang_ast::ObjectProp::KeyValue(k, v, s) => {
+                        tishlang_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v), *s)
                     }
                     tishlang_ast::ObjectProp::Spread(e) => {
                         tishlang_ast::ObjectProp::Spread(optimize_expr(e))
@@ -578,7 +578,9 @@ fn js_number_to_string(value: f64) -> String {
         return "-Infinity".to_string();
     }
     if value == 0.0 {
-        return if value.is_sign_negative() { "-0" } else { "0" }.to_string();
+        // ECMAScript `Number::toString`: both `+0` and `-0` → `"0"` (a constant-folded
+        // `"" + (-0)` must match the runtime ToString, not the inspect form). (#247)
+        return "0".to_string();
     }
     let negative = value < 0.0;
     let sci = format!("{:e}", value.abs());

package/crates/tish_parser/src/lib.rs

@@ -45,6 +45,24 @@ mod tests {
         }
     }
 
+    // #158: a block's span — and the enclosing function's span — must end at the closing `}`, not
+    // overrun onto the statement on the following line.
+    #[test]
+    fn block_and_fn_spans_stop_at_closing_brace() {
+        // `}` is on line 3 (1-based); `let after` begins on line 4.
+        let program = parse("fn f(a) {\n  let x = a\n}\nlet after = 1\n").expect("parse");
+        let Statement::FunDecl { span, body, .. } = &program.statements[0] else {
+            panic!("expected FunDecl");
+        };
+        assert_eq!(span.end.0, 3, "fn span must end on the `}}` line, not the next statement: {span:?}");
+        assert_eq!(
+            body.span().end.0,
+            3,
+            "body block span must end on the `}}` line: {:?}",
+            body.span()
+        );
+    }
+
     #[test]
     fn test_object_literal_shorthand_single() {
         let program = parse("const o = { port }").expect("parse object shorthand");
@@ -62,7 +80,7 @@ mod tests {
         };
         assert_eq!(props.len(), 1);
         match &props[0] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "port");
                 if let Expr::Ident { ref name, .. } = v {
                     assert_eq!(name.as_ref(), "port");
@@ -92,11 +110,11 @@ mod tests {
         };
         assert_eq!(props.len(), 2);
         match &props[0] {
-            ObjectProp::KeyValue(k, _) => assert_eq!(k.as_ref(), "ai-a"),
+            ObjectProp::KeyValue(k, _, _) => assert_eq!(k.as_ref(), "ai-a"),
             _ => panic!("expected KeyValue prop"),
         }
         match &props[1] {
-            ObjectProp::KeyValue(k, _) => assert_eq!(k.as_ref(), "human"),
+            ObjectProp::KeyValue(k, _, _) => assert_eq!(k.as_ref(), "human"),
             _ => panic!("expected KeyValue prop"),
         }
     }
@@ -118,7 +136,7 @@ mod tests {
         };
         assert_eq!(props.len(), 2);
         match &props[0] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "port");
                 if let Expr::Ident { ref name, .. } = v {
                     assert_eq!(name.as_ref(), "port");
@@ -129,7 +147,7 @@ mod tests {
             _ => panic!("expected KeyValue prop"),
         }
         match &props[1] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "x");
                 if let Expr::Literal { .. } = v {
                     // x: 1

package/crates/tish_parser/src/parser.rs

@@ -364,27 +364,21 @@ impl<'a> Parser<'a> {
             statements.push(self.parse_statement()?);
         }
 
+        // Block ends at its CLOSING `}`/`Dedent`. Capture that token's end BEFORE advancing past it:
+        // reading `self.peek()` *after* the advance pointed at the NEXT token, overrunning the block
+        // span onto the following statement — so a cursor on the line after `}` was still "inside"
+        // the block and completion offered the body's params/locals there (#158). Fall back to the
+        // last inner statement's end for an unterminated block at EOF, else the block start.
+        let mut closer_end: Option<(usize, usize)> = None;
         if matches!(
             self.peek_kind(),
             Some(TokenKind::RBrace | TokenKind::Dedent)
         ) {
+            closer_end = self.peek().map(|t| t.span.end);
             self.advance();
         }
-
-        let peek_end = self.peek().map(|x| x.span.end);
         let last_end = statements.last().map(|s| s.span().end);
-        let end = match (peek_end, last_end) {
-            (Some(p), Some(l)) => {
-                if p.0 > l.0 || (p.0 == l.0 && p.1 > l.1) {
-                    p
-                } else {
-                    l
-                }
-            }
-            (Some(p), None) => p,
-            (None, Some(l)) => l,
-            (None, None) => span_start,
-        };
+        let end = closer_end.or(last_end).unwrap_or(span_start);
 
         Ok(Statement::Block {
             statements,
@@ -985,17 +979,12 @@ impl<'a> Parser<'a> {
             Box::new(self.parse_block()?)
         };
 
-        // Span must cover the whole declaration through the body. `peek().start` alone can sit on
-        // the opening `{` (same as `span_start` at EOF) or otherwise truncate before inner spans.
-        let peek_start = self.peek().map(|t| t.span.start).unwrap_or(span_start);
-        let body_end = body.as_ref().span().end;
-        let end = if peek_start.0 > body_end.0
-            || (peek_start.0 == body_end.0 && peek_start.1 > body_end.1)
-        {
-            peek_start
-        } else {
-            body_end
-        };
+        // The declaration spans from `fn`/`async` through the END of its body. `parse_block` now
+        // ends the body block exactly at its closing `}` (#158), so the body's end IS the function's
+        // end. (This previously maxed with `peek().start` — the NEXT token after the function — to
+        // compensate for the old block-span truncation, which instead overran the function span past
+        // `}` and inflated its folding / document-symbol range onto the following line. #158)
+        let end = body.as_ref().span().end;
 
         Ok(Statement::FunDecl {
             async_,
@@ -2243,7 +2232,7 @@ impl<'a> Parser<'a> {
                                 return Err("String key in object literal requires explicit value (key: value)".to_string());
                             }
                         };
-                        props.push(ObjectProp::KeyValue(key, value));
+                        props.push(ObjectProp::KeyValue(key, value, key_span));
                     }
                     if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
                         self.expect(TokenKind::Comma)?;

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);
@@ -3695,7 +3759,7 @@ fn tref_expr(expr: &Expr, out: &mut Vec<TypeOcc>) {
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    tishlang_ast::ObjectProp::KeyValue(_, e)
+                    tishlang_ast::ObjectProp::KeyValue(_, e, _)
                     | tishlang_ast::ObjectProp::Spread(e) => tref_expr(e, out),
                 }
             }
@@ -4159,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) => {
@@ -4317,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";
@@ -4390,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).
@@ -4710,3 +4856,27 @@ mod tests {
         );
     }
 }
+
+#[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:?}");
+    }
+}