ucn 4.0.1 → 4.1.0

package/core/search.js

@@ -8,10 +8,11 @@
 'use strict';
 
 const path = require('path');
-const { escapeRegExp } = require('./shared');
+const { escapeRegExp, codeUnitCompare, inlineTestRanges, lineInRanges, classDispatchNames } = require('./shared');
 const { isTestFile } = require('./discovery');
 const { detectLanguage, getParser, getLanguageModule, langTraits } = require('../languages');
 const { getCachedCalls } = require('./callers');
+const { extractImports } = require('./imports');
 
 /**
  * Build a glob-style matcher: * matches any sequence, ? matches one char.
@@ -59,7 +60,7 @@ function find(index, name, options = {}) {
                     all.push({ ...sym, _fuzzyScore: 800 });
                 }
             }
-            all.sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+            all.sort((a, b) => codeUnitCompare((a.name || ''), b.name || ''));
             return _applyFindFilters(index, all, options);
         }
         const globRegex = new RegExp('^' + name.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
@@ -71,7 +72,7 @@ function find(index, name, options = {}) {
                 }
             }
         }
-        matches.sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+        matches.sort((a, b) => codeUnitCompare((a.name || ''), b.name || ''));
         return _applyFindFilters(index, matches, options);
     }
 
@@ -233,6 +234,16 @@ function usages(index, name, options = {}) {
                     return _importedHasDef;
                 };
 
+                // A qualified usage whose RECEIVER is a symbol defined in this
+                // file is never external-package noise — `Geometry.area(3, 4)`
+                // in the file declaring namespace Geometry was dropped by the
+                // receiver filter while find's usageCounts counted it (fix
+                // #241). Keyed on the receiver, not the target name: a file
+                // defining its own `Separator` while using external
+                // `Ns.Separator` must still filter the latter (bug #23).
+                const receiverDefinedHere = (recv) =>
+                    !!recv && fileEntry.symbols && fileEntry.symbols.some(s => s.name === recv);
+
                 for (const u of astUsages) {
                     // Skip if this is a definition line (already added above)
                     if (definitions.some(d => d.file === filePath && d.startLine === u.line)) {
@@ -241,12 +252,13 @@ function usages(index, name, options = {}) {
 
                     // Filter member expressions with unrelated receivers in JS/TS/Python.
                     // Keeps: standalone usages, self/this/cls/super, method calls on known types,
+                    //        qualified usages whose receiver this file defines,
                     //        and module access (output.fn()) when the imported file defines the name.
                     // Filters: namespace access to external packages (DropdownMenuPrimitive.Separator).
                     if (u.receiver && !['self', 'this', 'cls', 'super'].includes(u.receiver) &&
                         fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
                         const hasMethodDef = definitions.some(d => d.className);
-                        if (!hasMethodDef && !importedFileHasDef()) {
+                        if (!hasMethodDef && !receiverDefinedHere(u.receiver) && !importedFileHasDef()) {
                             continue;
                         }
                     }
@@ -563,6 +575,8 @@ function structuralSearch(index, options = {}) {
     index._beginOp();
     try {
         const { term, param, receiver, returns: returnType, decorator, exported, unused } = options;
+        let unusedDecoratorNames = null; // lazy — built once per --unused search (fix #234)
+        let selfRecursiveMemo = null;    // lazy — per-name self-recursion verdicts (fix #253c)
         // Auto-infer type: --receiver implies type=call
         const type = options.type || (receiver ? 'call' : undefined);
         const results = [];
@@ -620,25 +634,38 @@ function structuralSearch(index, options = {}) {
                 if (!calls) continue;
                 for (const call of calls) {
                     if (nameMatcher && !nameMatcher(call.name)) continue;
+                    // Field-hop receivers (`tm.service.Save()`) carry
+                    // receiverRoot/receiverField instead of receiver —
+                    // expose the dotted form so --receiver can match them
+                    // and the call renders with its receiver (fix #237).
+                    const callReceiver = call.receiver ||
+                        (call.receiverField
+                            ? (call.receiverRoot ? `${call.receiverRoot}.${call.receiverField}` : call.receiverField)
+                            : null);
                     if (receiver) {
-                        if (!call.receiver) continue;
-                        if (!matchesSubstring(call.receiver, receiver, options.caseSensitive)) continue;
+                        if (!callReceiver) continue;
+                        if (!matchesSubstring(callReceiver, receiver, options.caseSensitive)) continue;
                     }
                     results.push({
                         kind: 'call',
-                        name: call.receiver ? `${call.receiver}.${call.name}` : call.name,
+                        name: callReceiver ? `${callReceiver}.${call.name}` : call.name,
                         file: fileEntry.relativePath,
                         line: call.line,
-                        receiver: call.receiver || null,
+                        receiver: callReceiver,
                         isMethod: call.isMethod || false,
                     });
                 }
             }
         } else {
-            // Search symbols (functions, classes, methods, types)
-            const functionTypes = new Set(['function', 'constructor', 'method', 'arrow', 'static', 'classmethod', 'abstract']);
-            const classTypes = new Set(['class', 'struct', 'interface', 'impl', 'trait']);
-            const typeTypes = new Set(['type', 'enum', 'interface', 'trait']);
+            // Search symbols (functions, classes, methods, types).
+            // Every indexed symbol kind must be reachable through some type
+            // filter (fix #237): 'private'/'property' are function defs
+            // (Python underscore methods, @property members — both already
+            // match --type method via isMethod); Java records and enums are
+            // classes, and records are types too.
+            const functionTypes = new Set(['function', 'constructor', 'method', 'arrow', 'static', 'classmethod', 'abstract', 'private', 'property']);
+            const classTypes = new Set(['class', 'struct', 'interface', 'impl', 'trait', 'record', 'enum']);
+            const typeTypes = new Set(['type', 'enum', 'interface', 'trait', 'record', 'namespace']);
             const methodTypes = new Set(['method', 'constructor']);
 
             for (const [symbolName, definitions] of index.symbols) {
@@ -698,7 +725,57 @@ function structuralSearch(index, options = {}) {
                     // Unused filter (expensive — last check)
                     if (unused) {
                         index.buildCalleeIndex();
-                        if (index.calleeIndex.has(symbolName)) continue;
+                        // A name whose every call site is its own recursion
+                        // has zero callers (fix #253c — the deadcode
+                        // carve-out, applied here). Class-kind names are
+                        // exempt: class liveness is reference-based
+                        // (`Color.RED` keeps enum Color alive) and --unused
+                        // has no text scan to see references — deadcode is
+                        // the command with that safety net. Memoized per search.
+                        if (!selfRecursiveMemo) selfRecursiveMemo = new Map();
+                        const selfOnly = (n) => {
+                            if (!selfRecursiveMemo.has(n)) {
+                                const defs = index.symbols.get(n) || [];
+                                const classLike = defs.some(d => classTypes.has(d.type) || d.type === 'namespace');
+                                const { nameOnlySelfRecursive } = require('./deadcode');
+                                selfRecursiveMemo.set(n, !classLike && nameOnlySelfRecursive(index, n));
+                            }
+                            return selfRecursiveMemo.get(n);
+                        };
+                        if (index.calleeIndex.has(symbolName) && !selfOnly(symbolName)) continue;
+                        // Constructor members are invoked through the CLASS
+                        // name (fix #239): `new Widget()` indexes under
+                        // 'Widget', never under 'constructor'/'__init__'.
+                        if (def.className &&
+                            (def.type === 'constructor' || symbolName === 'constructor' || symbolName === '__init__') &&
+                            index.calleeIndex.has(def.className) && !selfOnly(def.className)) continue;
+                        // Runtime-invoked entry points are never unused (fix
+                        // #234, campaign G2 ×4 languages: Go main/init, Java
+                        // main, Rust main/#[test] all listed — the deadcode
+                        // protection, applied here).
+                        const langModule = fileEntry && getLanguageModule(fileEntry.language);
+                        if (langModule?.isEntryPoint?.(def)) continue;
+                        // A bare decorator application (@with_logging) invokes
+                        // the decorator at import time but is recorded as a
+                        // reference, not a call — a name decorating any def is
+                        // used (G2-python BUG-1).
+                        if (!unusedDecoratorNames) {
+                            unusedDecoratorNames = new Set();
+                            for (const [, dDefs] of index.symbols) {
+                                for (const d of dDefs) {
+                                    for (const dec of d.decorators || []) {
+                                        const base = String(dec).replace(/^@/, '').split('(')[0].trim();
+                                        unusedDecoratorNames.add(base);
+                                        // Dotted decorators (@bus.subscribe) invoke the
+                                        // METHOD — protect the last segment too (fix
+                                        // #243, the deadcode false-dead's twin here).
+                                        const lastSeg = base.split('.').pop();
+                                        if (lastSeg && lastSeg !== base) unusedDecoratorNames.add(lastSeg);
+                                    }
+                                }
+                            }
+                        }
+                        if (unusedDecoratorNames.has(symbolName)) continue;
                     }
 
                     // Merge decorators from both Python-style decorators and Java-style modifiers
@@ -720,7 +797,7 @@ function structuralSearch(index, options = {}) {
         }
 
         // Sort by file, then line
-        results.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+        results.sort((a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line);
 
         // Apply top limit
         const total = results.length;
@@ -765,6 +842,9 @@ function example(index, name, options = {}) {
     const usageResults = usages(index, name, {
         codeOnly: true,
         className: options.className,
+        // Scope examples to files matching --file (the flag was accepted but
+        // silently ignored before).
+        file: options.file,
         exclude,
         context: 5
     });
@@ -778,6 +858,7 @@ function example(index, name, options = {}) {
             const allUsages = usages(index, name, {
                 codeOnly: true,
                 className: options.className,
+                file: options.file,
                 exclude: [],
                 context: 0,
             });
@@ -832,8 +913,10 @@ function example(index, name, options = {}) {
     const best = scored[0];
 
     // Default behavior: one best representative.
+    // Advisory command (v4 two-tier surface): scored example selection, not
+    // a verified "best" claim.
     if (!options.diverse) {
-        return { best, totalCalls: calls.length };
+        return { advisory: 'scored-selection', best, totalCalls: calls.length };
     }
 
     // --diverse: cluster call sites by AST argument-shape and return one
@@ -869,7 +952,7 @@ function example(index, name, options = {}) {
 
     // Order clusters: largest first, ties broken by shapeKey for determinism.
     const clusterList = [...clusterMap.values()].sort((a, b) =>
-        (b.count - a.count) || a.shapeKey.localeCompare(b.shapeKey)
+        (b.count - a.count) || codeUnitCompare(a.shapeKey, b.shapeKey)
     );
 
     // Pick representative per cluster: highest-scoring member; ties broken
@@ -877,7 +960,7 @@ function example(index, name, options = {}) {
     const clusters = clusterList.slice(0, top).map(cluster => {
         const sortedMembers = [...cluster.members].sort((a, b) =>
             (b.score - a.score) ||
-            (a.relativePath || a.file || '').localeCompare(b.relativePath || b.file || '') ||
+            codeUnitCompare((a.relativePath || a.file || ''), b.relativePath || b.file || '') ||
             (a.line || 0) - (b.line || 0)
         );
         const rep = sortedMembers[0];
@@ -891,6 +974,7 @@ function example(index, name, options = {}) {
     });
 
     return {
+        advisory: 'scored-selection',
         best,
         totalCalls: calls.length,
         clusters,
@@ -908,7 +992,7 @@ function example(index, name, options = {}) {
  * @returns {Array} Matching type definitions
  */
 function typedef(index, name, options = {}) {
-    const typeKinds = ['type', 'interface', 'enum', 'struct', 'trait', 'class', 'record'];
+    const typeKinds = ['type', 'interface', 'enum', 'struct', 'trait', 'class', 'record', 'namespace'];
     const matches = find(index, name, options);
 
     return matches.filter(m => typeKinds.includes(m.type)).map(m => ({
@@ -959,12 +1043,13 @@ function tests(index, nameOrFile, options = {}) {
         if (isTestFile(fileEntry.relativePath, fileEntry.language)) {
             testFiles.push({ path: filePath, entry: fileEntry });
         } else if (fileEntry.language === 'rust') {
-            // Rust idiomatically puts tests in #[cfg(test)] modules inside source files.
-            const hasInlineTests = fileEntry.symbols?.some(s =>
-                s.modifiers?.includes('test')
-            );
-            if (hasInlineTests) {
-                testFiles.push({ path: filePath, entry: fileEntry });
+            // Rust idiomatically puts tests in #[cfg(test)] modules inside
+            // source files. Such a file is test code ONLY within its inline
+            // test ranges — matching its production lines claimed false
+            // coverage (fix #244).
+            const ranges = inlineTestRanges(fileEntry);
+            if (ranges.length > 0) {
+                testFiles.push({ path: filePath, entry: fileEntry, testRanges: ranges });
             }
         }
     }
@@ -973,24 +1058,62 @@ function tests(index, nameOrFile, options = {}) {
         ? path.basename(nameOrFile, path.extname(nameOrFile))
         : nameOrFile;
 
+    // File-path target: module specifiers are string literals, so the
+    // basename usage scan is blind to import-linked tests in JS/TS
+    // (fix #246). Resolve the target file(s) so each test file's resolved
+    // imports can be checked against them.
+    let targetRels = null;
+    if (isFilePath) {
+        const norm = nameOrFile.replace(/\\/g, '/');
+        targetRels = new Set();
+        for (const [, fe] of index.files) {
+            const rp = fe.relativePath;
+            if (rp === norm || rp.endsWith('/' + norm) || path.basename(rp) === norm) {
+                targetRels.add(rp);
+            }
+        }
+        if (targetRels.size === 0) targetRels = null;
+    }
+
     const className = options.className || null;
+    // className scoping accepts the class plus its non-overriding
+    // descendants — a subclass instance without its own override dispatches
+    // to the target class's method (fix #246).
+    const dispatchNames = className ? classDispatchNames(index, className, searchTerm) : null;
     // Pre-compile string-ref pattern (only regex left — used on single AST-identified lines)
     const strPattern = new RegExp("['\"`]" + escapeRegExp(searchTerm) + "['\"`]");
 
     // --exclude filtering
     const excludeArr = options.exclude ? (Array.isArray(options.exclude) ? options.exclude : [options.exclude]) : [];
 
-    for (const { path: testPath, entry } of testFiles) {
+    for (const { path: testPath, entry, testRanges } of testFiles) {
         try {
             // Apply exclude filters
             if (excludeArr.length > 0 && !index.matchesFilters(entry.relativePath, { exclude: excludeArr })) continue;
 
             const content = index._readFile(testPath);
 
+            // File-path target: import records resolving to the target file
+            // link this test regardless of what the basename scan sees.
+            let linkedRecords = null;
+            if (targetRels && entry.moduleResolved) {
+                const linkedModules = new Set();
+                for (const [mod, rel] of Object.entries(entry.moduleResolved)) {
+                    if (targetRels.has(rel)) linkedModules.add(mod);
+                }
+                if (linkedModules.size > 0) {
+                    const { imports: recs } = extractImports(content, entry.language);
+                    const hits = (recs || []).filter(r => linkedModules.has(r.module));
+                    if (hits.length > 0) linkedRecords = hits;
+                }
+            }
+
             // Fast pre-check: skip if searchTerm doesn't appear in file
-            if (!content.includes(searchTerm)) continue;
-            // className scoping: skip test files that don't reference the class at all
-            if (className && !content.includes(className)) continue;
+            if (!content.includes(searchTerm) && !linkedRecords) continue;
+            // className scoping: skip test files that reference neither the
+            // class nor any non-overriding subclass (fix #246 — a test
+            // holding only a Circle exercises Shape.describe).
+            if (className && ![...dispatchNames].some(dn => content.includes(dn))) continue;
 
             // --file scoping: only include test files that import from the target source
             if (sourceFileFilter && !sourceFileFilter.has(testPath)) {
@@ -998,17 +1121,37 @@ function tests(index, nameOrFile, options = {}) {
             }
 
             // AST-based usage detection
-            const astUsages = index._getCachedUsages(testPath, searchTerm);
-            if (astUsages === null) continue; // no parser available — skip
-
-            if (astUsages.length === 0) continue;
+            const astUsages = index._getCachedUsages(testPath, searchTerm) || [];
+            if (astUsages.length === 0 && !linkedRecords) continue;
+
+            // A test file that DEFINES searchTerm itself owns bare-name
+            // calls of it (fix #246 — the #244 affectedTests rule, tests()
+            // twin): such calls bind the test's own helper, not the project
+            // symbol. Exception: inline-test-promoted files whose PRODUCTION
+            // ranges define the symbol — the file defines AND tests it, so
+            // bare calls in test ranges bind the project symbol.
+            let localShadow = false;
+            if (!isFilePath) {
+                const localDefs = (entry.symbols || []).filter(s => s.name === searchTerm);
+                if (localDefs.length > 0 &&
+                    !(entry.importBindings || []).some(b => b.name === searchTerm)) {
+                    localShadow = testRanges
+                        ? localDefs.every(s => lineInRanges(s.startLine, testRanges))
+                        : true;
+                }
+            }
 
             // Build instance variable → className map from getCachedCalls()
             // for receiver-precise className scoping.
             // e.g., `const svc = new B()` → svc maps to 'B'
             let instanceTypeMap = null; // lazily built
             if (className) {
-                instanceTypeMap = _buildInstanceTypeMap(index, testPath, content, className);
+                instanceTypeMap = new Map();
+                for (const dn of dispatchNames) {
+                    for (const [recv, cls] of _buildInstanceTypeMap(index, testPath, content, dn)) {
+                        if (!instanceTypeMap.has(recv)) instanceTypeMap.set(recv, cls);
+                    }
+                }
             }
 
             const matches = [];
@@ -1016,6 +1159,12 @@ function tests(index, nameOrFile, options = {}) {
 
             for (const usage of astUsages) {
                 if (usage.usageType === 'definition') continue; // not relevant in test files
+                // Inline-test-promoted file: only lines inside the test
+                // ranges are test code (fix #244).
+                if (testRanges && !lineInRanges(usage.line, testRanges)) continue;
+                // Local same-name shadow: bare usages bind the test file's
+                // own definition (fix #246).
+                if (localShadow && !usage.receiver && usage.usageType !== 'import') continue;
 
                 const lineKey = `${usage.line}:${usage.usageType}`;
                 if (seenLines.has(lineKey)) continue;
@@ -1035,7 +1184,7 @@ function tests(index, nameOrFile, options = {}) {
 
                 // className scoping for calls: check receiver
                 if (className && matchType === 'call') {
-                    if (!_receiverMatchesClass(usage, className, instanceTypeMap, lineContent, searchTerm)) continue;
+                    if (!_receiverMatchesClass(usage, dispatchNames, instanceTypeMap, lineContent, searchTerm)) continue;
                 }
 
                 // className scoping for references: require class-associated receiver
@@ -1044,8 +1193,8 @@ function tests(index, nameOrFile, options = {}) {
                     // association — skip them. Only keep member-access references
                     // where the receiver matches the target class.
                     if (!usage.receiver) continue;
-                    if (usage.receiver !== className &&
-                        !(instanceTypeMap && instanceTypeMap.get(usage.receiver) === className)) {
+                    if (!dispatchNames.has(usage.receiver) &&
+                        !(instanceTypeMap && dispatchNames.has(instanceTypeMap.get(usage.receiver)))) {
                         continue;
                     }
                 }
@@ -1057,8 +1206,47 @@ function tests(index, nameOrFile, options = {}) {
                 });
             }
 
-            // Language-aware test-case detection
-            _addTestCaseMatches(index, testPath, entry, searchTerm, className, instanceTypeMap, matches);
+            // File-path target: surface the linking import lines and usages
+            // of each name imported from the target file (fix #246).
+            if (linkedRecords) {
+                for (const rec of linkedRecords) {
+                    if (rec.line != null && !(testRanges && !lineInRanges(rec.line, testRanges))) {
+                        const lineKey = `${rec.line}:import`;
+                        if (!seenLines.has(lineKey)) {
+                            seenLines.add(lineKey);
+                            matches.push({
+                                line: rec.line,
+                                content: (index.getLineContent(testPath, rec.line) || '').trim(),
+                                matchType: 'import'
+                            });
+                        }
+                    }
+                    for (const nm of rec.names || []) {
+                        if (nm === searchTerm) continue; // basename scan covered it
+                        const nmUsages = index._getCachedUsages(testPath, nm) || [];
+                        for (const u of nmUsages) {
+                            if (u.usageType === 'definition' || u.usageType === 'import') continue;
+                            if (testRanges && !lineInRanges(u.line, testRanges)) continue;
+                            const lineKey = `${u.line}:${u.usageType}:${nm}`;
+                            if (seenLines.has(lineKey)) continue;
+                            seenLines.add(lineKey);
+                            const lc = index.getLineContent(testPath, u.line);
+                            matches.push({
+                                line: u.line,
+                                content: lc.trim(),
+                                matchType: u.usageType === 'call' ? 'call' : 'reference'
+                            });
+                        }
+                    }
+                }
+            }
+
+            // Language-aware test-case detection. Under a local same-name
+            // shadow the term on a test line is the file's OWN helper —
+            // only anchor test cases to matches that survived the shadow.
+            if (!localShadow || matches.some(m => m.matchType !== 'import')) {
+                _addTestCaseMatches(index, testPath, entry, searchTerm, className, instanceTypeMap, matches);
+            }
 
             // Deduplicate: if a line already has a 'call' or 'import', don't also add 'test-case'
             let finalMatches = _deduplicateMatches(matches);
@@ -1192,6 +1380,25 @@ function _buildSourceFileImporters(index, defs) {
                 continue;
             }
 
+            // Java: same-package tests need no import statement either — a
+            // test file in the same directory sees the source's package
+            // members directly (fix #244: tests --file silently dropped
+            // MathIntegrationTest.java while affected-tests found it).
+            if (srcEntry.language === 'java' && testDir === srcDir) {
+                importers.add(absPath);
+                continue;
+            }
+
+            // Rust: Cargo integration tests live in <crate-root>/tests/ and
+            // import via the crate's PACKAGE name, which the import resolver
+            // does not map to project files (fix #244).
+            if (srcEntry.language === 'rust' &&
+                path.basename(testDir) === 'tests' &&
+                srcPath.startsWith(path.dirname(testDir) + path.sep)) {
+                importers.add(absPath);
+                continue;
+            }
+
             // Rust: inline tests in the source file itself
             if (srcPath === absPath) {
                 importers.add(absPath);
@@ -1292,25 +1499,30 @@ function _buildInstanceTypeMap(index, filePath, content, targetClassName) {
  * @param {Map} instanceTypeMap - varName → className map
  * @param {string} [lineContent] - Line content for fallback checks
  */
-function _receiverMatchesClass(usage, className, instanceTypeMap, lineContent, searchTerm) {
-    // Direct receiver: ClassName.method() or ClassName.staticMethod()
-    if (usage.receiver === className) return true;
-    // Instance variable: check if receiver is bound to the target class
-    if (usage.receiver && instanceTypeMap && instanceTypeMap.get(usage.receiver) === className) return true;
+function _receiverMatchesClass(usage, dispatchNames, instanceTypeMap, lineContent, searchTerm) {
+    // Direct receiver: ClassName.method() or ClassName.staticMethod().
+    // dispatchNames is the target class plus its non-overriding descendants
+    // (fix #246) — an instance of such a subclass runs the target's method.
+    if (usage.receiver && dispatchNames.has(usage.receiver)) return true;
+    // Instance variable: check if receiver is bound to a dispatching class
+    if (usage.receiver && instanceTypeMap && dispatchNames.has(instanceTypeMap.get(usage.receiver))) return true;
     // Receiver is some other known identifier — doesn't match
     if (usage.receiver) return false;
-    // No receiver: bare function call. Only match if className is the direct
-    // receiver expression — e.g., `new B().save()`, `B().save()`, `B{}.save()`.
-    // Reject cases like `svc = B(); save()` where className is elsewhere on the line.
+    // No receiver: bare function call. Only match if a dispatching class is
+    // the direct receiver expression — e.g., `new B().save()`, `B().save()`,
+    // `B{}.save()`. Reject cases like `svc = B(); save()` where the class
+    // name is elsewhere on the line.
     if (lineContent && searchTerm) {
-        // Check for chained call: ClassName followed by constructor/call then .methodName(
-        const pat = new RegExp(
-            '\\b' + escapeRegExp(className) + '\\s*(?:(?:\\([^)]*\\)|\\{[^}]*\\})\\s*\\.\\s*' +
-            escapeRegExp(searchTerm) + '\\s*\\(|' +
-            'new\\s+' + escapeRegExp(className) + '\\s*\\([^)]*\\)\\s*\\.\\s*' +
-            escapeRegExp(searchTerm) + '\\s*\\()'
-        );
-        if (pat.test(lineContent)) return true;
+        for (const className of dispatchNames) {
+            // Check for chained call: ClassName followed by constructor/call then .methodName(
+            const pat = new RegExp(
+                '\\b' + escapeRegExp(className) + '\\s*(?:(?:\\([^)]*\\)|\\{[^}]*\\})\\s*\\.\\s*' +
+                escapeRegExp(searchTerm) + '\\s*\\(|' +
+                'new\\s+' + escapeRegExp(className) + '\\s*\\([^)]*\\)\\s*\\.\\s*' +
+                escapeRegExp(searchTerm) + '\\s*\\()'
+            );
+            if (pat.test(lineContent)) return true;
+        }
     }
     return false;
 }
@@ -1333,11 +1545,14 @@ function _addTestCaseMatches(index, filePath, fileEntry, searchTerm, className,
         const calls = getCachedCalls(index, filePath);
         if (!calls) return;
         const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
+        // Word-boundary match: `describe("untargeted zone")` is not a test
+        // case for `target` (fix #246 — raw substring matched mid-word).
+        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(searchTerm) + '([^\\w$]|$)');
         for (const call of calls) {
             if (!testFrameworkCalls.has(call.name)) continue;
             const lineContent = index.getLineContent(filePath, call.line);
             // Check if searchTerm appears in the description string on this line
-            if (lineContent.includes(searchTerm) && !matchLines.has(call.line)) {
+            if (termPattern.test(lineContent) && !matchLines.has(call.line)) {
                 // className scoping: only add test-case if the test body has a
                 // class-scoped match (call or class-receiver reference) — not just
                 // any mention of className.