ucn 4.2.3 → 5.0.2

package/core/analysis.js

@@ -13,8 +13,10 @@ const { execFileSync } = require('child_process');
 const { parse } = require('./parser');
 const { detectLanguage, langTraits } = require('../languages');
 const { NON_CALLABLE_TYPES, addTestExclusions, countTextBlindspots, codeUnitCompare } = require('./shared');
+const { isTestFile } = require('./discovery');
 const { computeReachability, symbolKey } = require('./entrypoints');
-const { getLanguageModule } = require('../languages');
+const { getLanguageAdapter } = require('../languages');
+const { projectComputedDispatch } = require('./ast-analysis');
 
 // JS/TS test framework helpers — calls to these bracket a test case.
 // Used to flag call sites whose enclosing function is an arrow callback
@@ -44,10 +46,11 @@ function tagInTestCase(index, sites) {
         const fe = index.files.get(filePath);
         if (!fe) { fileMeta.set(filePath, null); return null; }
         let langModule = null;
-        try { langModule = getLanguageModule(fe.language); } catch (_) { /* ignore */ }
+        try { langModule = getLanguageAdapter(fe.language); } catch (_) { /* ignore */ }
         const meta = { fileEntry: fe, langModule, language: fe.language, jsTestRanges: null };
         // For JS-family files, build line ranges of describe/it/test framework calls.
-        if (langModule && (fe.language === 'javascript' || fe.language === 'typescript' ||
+        if (langModule && isTestFile(fe.relativePath, fe.language) &&
+            (fe.language === 'javascript' || fe.language === 'typescript' ||
             fe.language === 'tsx' || fe.language === 'html')) {
             try {
                 const calls = index.getCachedCalls ? index.getCachedCalls(filePath) : null;
@@ -296,8 +299,12 @@ function context(index, name, options = {}) {
         !!(def.isMethod || def.type === 'method' || def.className);
 
     // Special handling for class/struct/interface types
-    if (['class', 'struct', 'interface', 'type'].includes(def.type)) {
-        const methods = index.findMethodsForType(name);
+    if (['class', 'struct', 'interface', 'type', 'enum', 'record', 'trait', 'namespace']
+        .includes(def.type)) {
+        const methods = index.findMethodsForType(name, def);
+        const members = (index.files.get(def.file)?.symbols || []).filter(symbol =>
+            symbol.className === def.name &&
+            ['field', 'constant', 'state'].includes(symbol.type));
 
         // Pin caller resolution to the resolved class definition — same as the
         // function path below. Without this, same-name classes in other files
@@ -332,6 +339,10 @@ function context(index, name, options = {}) {
         typeCallers = [...typeCallers].sort(byFileLine);
         typeUnverified = [...typeUnverified].sort(byFileLine);
 
+        const callerTotal = typeCallers.length;
+        if (options.maxCallers && options.maxCallers > 0) {
+            typeCallers = typeCallers.slice(0, options.maxCallers);
+        }
         const result = {
             type: def.type,
             name: name,
@@ -346,10 +357,16 @@ function context(index, name, options = {}) {
                 returnType: m.returnType,
                 receiver: m.receiver
             })),
+            members: members.map(member => ({
+                name: member.name,
+                type: member.type,
+                file: member.relativePath,
+                line: member.startLine,
+            })),
             // Also include places where the type is used in function parameters/returns
             callers: typeCallers,
             unverifiedCallers: typeUnverified,
-            meta: { account: typeAccount }
+            meta: { account: typeAccount, callerTotal }
         };
 
         if (warnings.length > 0) {
@@ -434,11 +451,16 @@ function context(index, name, options = {}) {
         return (a.startLine || 0) - (b.startLine || 0);
     });
 
-    // Trust signals: tag each caller/callee with reachability and build ordinal evidence histograms.
-    // Reachability is computed once per index and cached (see entrypoints.computeReachability).
-    const reachableSet = computeReachability(index);
-    tagCallersReachable(callers, reachableSet);
-    tagCalleesReachable(callees, reachableSet);
+    // Reachability is a whole-project BFS. Keep the default symbol query
+    // targeted; compute the enrichment only for the explicit unreachable
+    // filter, or validate/reuse an already available cache.
+    const reachableSet = (options.unreachableOnly || index._reachableSymbols)
+        ? computeReachability(index)
+        : null;
+    if (reachableSet) {
+        tagCallersReachable(callers, reachableSet);
+        tagCalleesReachable(callees, reachableSet);
+    }
 
     // Side-effect tags on callees (lazy-cached per symbol on the index)
     tagCalleesSideEffects(index, callees);
@@ -463,6 +485,14 @@ function context(index, name, options = {}) {
 
     const callerHistogram = buildHistogram(callers);
     const calleeHistogram = buildHistogram(callees);
+    const callerTotal = callers.length;
+    const calleeTotal = callees.length;
+    if (options.maxCallers && options.maxCallers > 0) {
+        callers = callers.slice(0, options.maxCallers);
+    }
+    if (options.maxCallees && options.maxCallees > 0) {
+        callees = callees.slice(0, options.maxCallees);
+    }
 
     const filesInScope = new Set([def.file]);
     callers.forEach(c => filesInScope.add(c.file));
@@ -496,9 +526,14 @@ function context(index, name, options = {}) {
             projectLanguage: index._getPredominantLanguage(),
             account,
             calleeAccount: rawCallees.calleeAccount,
+            callerTotal,
+            calleeTotal,
             // No detected entry points (e.g. library code) — reachability
-            // markers are meaningless and suppressed by formatters.
-            hasEntrypoints: reachableSet.size > 0,
+            // markers are meaningless and suppressed by formatters. Omit the
+            // field when the optional enrichment was not requested.
+            ...(reachableSet && {
+                hasEntrypoints: reachableSet.size > 0,
+            }),
             ...(options.all && { all: true }),
             // Structural facts for reliability hints
             ...(def.isMethod && { isMethod: true }),
@@ -627,6 +662,8 @@ function detectCompleteness(index) {
     let dynamicImports = 0;
     let evalUsage = 0;
     let reflectionUsage = 0;
+    let computedDispatchUsage = 0;
+    const computedDispatch = projectComputedDispatch(index);
 
     for (const [filePath, fileEntry] of index.files) {
         // Skip node_modules - we don't care about their patterns
@@ -650,6 +687,7 @@ function detectCompleteness(index) {
             const bs = countTextBlindspots(content, fileEntry.language);
             evalUsage += bs.eval;
             reflectionUsage += bs.reflection;
+            computedDispatchUsage += computedDispatch.get(filePath)?.length || 0;
         } catch (e) {
             // Skip unreadable files
         }
@@ -679,6 +717,14 @@ function detectCompleteness(index) {
         });
     }
 
+    if (computedDispatchUsage > 0) {
+        warnings.push({
+            type: 'computed_dispatch',
+            count: computedDispatchUsage,
+            message: `${computedDispatchUsage} computed dispatch call(s) detected - runtime-selected members are not statically attributable`,
+        });
+    }
+
     index._completenessCache = {
         complete: warnings.length === 0,
         warnings,
@@ -871,7 +917,7 @@ function related(index, name, options = {}) {
 function impact(index, name, options = {}) {
     index._beginOp();
     try {
-    const { def } = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
+    const { def, warnings } = index.resolveSymbol(name, { file: options.file, className: options.className, line: options.line });
     if (!def) {
         return null;
     }
@@ -901,7 +947,6 @@ function impact(index, name, options = {}) {
     let impactAccountRaw = null;
     let impactRoutedUnverified = []; // engine-routed retained drops (unverifiedEntries)
     const impactClaims = [];
-    const impactPostHocExcluded = [];
     const impactPostHocUnverified = [];
     if (options.className || defIsMethod || defIsTypeDef) {
         // findCallers has proper method call resolution (self/this, binding IDs, receiver checks)
@@ -958,7 +1003,6 @@ function impact(index, name, options = {}) {
         });
         impactAccountRaw = callerResults.accountRaw;
         impactRoutedUnverified = callerResults.unverifiedEntries || [];
-        const targetBindingId = def.bindingId;
         // Convert findCallers results to the format expected by analyzeCallSite
         const calls = callerResults.map(c => ({
             file: c.file,
@@ -975,36 +1019,20 @@ function impact(index, name, options = {}) {
             resolution: c.resolution,
             tier: c.tier,
         }));
-        // Keep the same binding filter for backward compat (findCallers already handles this,
-        // but cross-check with usages-based binding filter for safety)
-        const filteredCalls = calls.filter(u => {
-            const fileEntry = index.files.get(u.file);
-            if (fileEntry && targetBindingId) {
-                let localBindings = (fileEntry.bindings || []).filter(b => b.name === name);
-                if (localBindings.length === 0 && langTraits(fileEntry.language)?.packageScope === 'directory') {
-                    const dir = path.dirname(u.file);
-                    for (const [fp, fe] of index.files) {
-                        if (fp !== u.file && path.dirname(fp) === dir) {
-                            const sibling = (fe.bindings || []).filter(b => b.name === name);
-                            localBindings = localBindings.concat(sibling);
-                        }
-                    }
-                }
-                if (localBindings.length > 0 && !localBindings.some(b => b.id === targetBindingId)) {
-                    impactPostHocExcluded.push({ file: u.file, line: u.line, reason: 'other-definition' });
-                    return false;
-                }
-            }
-            return true;
-        });
-        // (findCallers already handles binding resolution and scope-aware filtering)
+        // findCallers already applied binding, receiver, module ownership, and
+        // target-definition pinning. Do not second-guess it with a file-level
+        // same-name binding scan: a wrapper method named `usages` can legally
+        // call `searchModule.usages()`, and the receiver proves that this is the
+        // imported standalone function rather than the local method. The old
+        // post-hoc filter dropped that confirmed edge from impact while show
+        // kept it, violating command parity.
 
         // Analyze each call site, filtering out method calls for non-method definitions
         callSites = [];
         const defFileEntry = index.files.get(def.file);
         const defLang = defFileEntry?.language;
         const targetDir = defLang === 'go' ? path.basename(path.dirname(def.file)) : null;
-        for (const call of filteredCalls) {
+        for (const call of calls) {
             const analysis = index.analyzeCallSite(call, name);
             // BUG-H3: when includeMethods is true, keep method-style calls
             // (e.g. obj.findCallers() resolves to standalone findCallers via the
@@ -1083,14 +1111,22 @@ function impact(index, name, options = {}) {
         impactFilteredByFlag.exclude += beforeUnverified - unverifiedSites.length;
     }
 
-    // Trust signals: tag each call site with reachability and build an ordinal evidence histogram.
-    // It is computed BEFORE top-N truncation so the evidence profile reflects the full scope.
-    const impactReachable = computeReachability(index);
-    for (const site of filteredSites) {
-        if (site.callerFile && site.callerStartLine != null) {
-            site.reachable = impactReachable.has(symbolKey(site.callerFile, site.callerStartLine));
+    // Reachability is a whole-project BFS and can dominate an otherwise
+    // targeted impact query. Compute it only when the caller requested the
+    // unreachable filter, or validate/reuse an already available cache.
+    // Default impact still returns the complete evidence-tiered call-site
+    // answer; `reachable` remains an optional enrichment.
+    const impactReachable = (options.unreachableOnly || index._reachableSymbols)
+        ? computeReachability(index)
+        : null;
+    if (impactReachable) {
+        for (const site of filteredSites) {
+            if (site.callerFile && site.callerStartLine != null) {
+                site.reachable = impactReachable.has(
+                    symbolKey(site.callerFile, site.callerStartLine));
+            }
+            // Module-level sites: no verdict — import-time execution (fix #256).
         }
-        // Module-level sites: no verdict — import-time execution (fix #256).
     }
     if (options.unreachableOnly) {
         const before = filteredSites.length;
@@ -1111,7 +1147,7 @@ function impact(index, name, options = {}) {
             if (cl.tier === 'unverified') unverifiedEntries.push(cl);
             else confirmedEntries.push(cl);
         }
-        const excludedEntries = [...(impactAccountRaw?.excludedEntries || []), ...impactPostHocExcluded];
+        const excludedEntries = impactAccountRaw?.excludedEntries || [];
         const filteredTotal = impactFilteredByFlag.exclude + impactFilteredByFlag.unreachableOnly;
         return buildAccount(index, name, {
             groundSet,
@@ -1186,7 +1222,7 @@ function impact(index, name, options = {}) {
         shownCallSites: filteredSites.length,
         unverifiedSites,
         account: impactAccount,
-        hasEntrypoints: impactReachable.size > 0,
+        hasEntrypoints: !!impactReachable && impactReachable.size > 0,
         callerHistogram,
         // Stable ordering: files alphabetical, sites by line ascending. Documented contract.
         byFile: Array.from(byFile.entries())
@@ -1197,7 +1233,8 @@ function impact(index, name, options = {}) {
                 sites: [...sites].sort((s1, s2) => (s1.line || 0) - (s2.line || 0))
             })),
         patterns,
-        scopeWarning
+        scopeWarning,
+        ...(warnings.length > 0 && { warnings }),
     };
     } finally { index._endOp(); }
 }
@@ -1316,6 +1353,7 @@ function about(index, name, options = {}) {
     let allCallees = null;
     let aboutConfFiltered = 0;
     let aboutAccount = null;
+    let aboutReachable = null;
     let aboutUnverified = { total: 0, top: [] };
     // BUG-M3: include classes/structs/interfaces — `new Foo()` invocations are
     // tracked as calls in the parser (isConstructor:true) and findCallers resolves
@@ -1374,10 +1412,14 @@ function about(index, name, options = {}) {
         }
         const unverifiedShadowCount = shadowSurvivors.filter(s => s.tier === 'unverified').length;
         shadowSurvivors = shadowSurvivors.filter(s => s.tier !== 'unverified');
-        // Tag reachability on raw caller objects so we can preserve the field on the projection.
-        // Reachability is computed once per index and cached.
-        const aboutReachable = computeReachability(index);
-        tagCallersReachable(allCallers, aboutReachable);
+        // Whole-project reachability is optional enrichment. Compute it only
+        // for the explicit filter, or validate/reuse an existing cache.
+        aboutReachable = (options.unreachableOnly || index._reachableSymbols)
+            ? computeReachability(index)
+            : null;
+        if (aboutReachable) {
+            tagCallersReachable(allCallers, aboutReachable);
+        }
 
         // Optional: filter to unreachable-only callers
         if (options.unreachableOnly) {
@@ -1491,7 +1533,9 @@ function about(index, name, options = {}) {
         }
 
         // Tag callee reachability + optional unreachable-only filter
-        tagCalleesReachable(allCallees, aboutReachable);
+        if (aboutReachable) {
+            tagCalleesReachable(allCallees, aboutReachable);
+        }
         if (options.unreachableOnly) {
             allCallees = allCallees.filter(c => !c.reachable);
         }
@@ -1639,7 +1683,9 @@ function about(index, name, options = {}) {
         code,
         includeMethods,
         ...(aboutAccount && { account: aboutAccount }),
-        ...(allCallers && { hasEntrypoints: computeReachability(index).size > 0 }),
+        ...(allCallers && aboutReachable && {
+            hasEntrypoints: aboutReachable.size > 0,
+        }),
         ...(aboutConfFiltered > 0 && { confidenceFiltered: aboutConfFiltered }),
         // BUG-M4: surface ambiguous-resolution warnings so formatters can render
         // a "auto-selected ... pass --file to choose" note.
@@ -1684,7 +1730,7 @@ function diffImpact(index, options = {}) {
     try {
         gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: index.root, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
     } catch (e) {
-        throw new Error('Not a git repository. diff-impact requires git.', { cause: e });
+        throw new Error('Not a git repository. impact without a symbol requires git.', { cause: e });
     }
 
     // Build git diff command (use execFileSync to avoid shell expansion)
@@ -2272,7 +2318,9 @@ function parseDiff(diffText, root) {
 // Languages for which audit-async runs (those with async/await keyword we
 // track). Go/Java/Rust have async machinery but audit-async is scoped to
 // JS/TS/Python per spec.
-const _AUDIT_ASYNC_LANGS = new Set(['javascript', 'typescript', 'tsx', 'python', 'html']);
+const _AUDIT_ASYNC_LANGS = new Set([
+    'javascript', 'typescript', 'tsx', 'python', 'html', 'csharp',
+]);
 
 // Built-in/standard-library callees that return promises and are commonly
 // missing-awaited. Conservative starter set (rule #9 — generic, not
@@ -2293,6 +2341,9 @@ const _KNOWN_ASYNC_CALLEES = new Set([
 //   - void <expr>
 //   - <expr>.then() / .catch() (the call provides its own handler)
 const _FIRE_AND_FORGET_PROMISE_FNS = new Set(['all', 'allSettled', 'race', 'any']);
+const _ASYNCIO_CONSUMER_FNS = new Set([
+    'gather', 'create_task', 'ensure_future', 'wait', 'as_completed',
+]);
 
 /**
  * Run an async/await audit across the project.
@@ -2309,7 +2360,7 @@ const _FIRE_AND_FORGET_PROMISE_FNS = new Set(['all', 'allSettled', 'race', 'any'
  *      to a variable — these are intentional non-await uses).
  *
  * Detection is AST-based per language; the language must support an
- * `await` keyword (JS/TS/Python). Other languages are skipped.
+ * `await` keyword (JS/TS/Python/C#). Other languages are skipped.
  *
  * @param {object} index - ProjectIndex instance
  * @param {object} [options] - { file, exclude }
@@ -2318,7 +2369,7 @@ const _FIRE_AND_FORGET_PROMISE_FNS = new Set(['all', 'allSettled', 'race', 'any'
 function auditAsync(index, options = {}) {
     index._beginOp();
     try {
-        const { getParser, getLanguageModule, safeParse } = require('../languages');
+        const { getParser, getLanguageAdapter, safeParse } = require('../languages');
         const issues = [];
 
         // Build a "is this name provably async" lookup from the symbol table.
@@ -2380,8 +2431,10 @@ function auditAsync(index, options = {}) {
                             if (obj && prop) {
                                 const objText = obj.text;
                                 const propText = prop.text;
-                                if ((objText === 'Promise' || objText === 'asyncio') &&
-                                    _FIRE_AND_FORGET_PROMISE_FNS.has(propText)) {
+                                if ((objText === 'Promise' &&
+                                    _FIRE_AND_FORGET_PROMISE_FNS.has(propText)) ||
+                                    (objText === 'asyncio' &&
+                                    _ASYNCIO_CONSUMER_FNS.has(propText))) {
                                     return true;
                                 }
                                 // .then(...) / .catch(...) — caller is providing a handler;
@@ -2430,6 +2483,9 @@ function auditAsync(index, options = {}) {
         function processFile(filePath, fileEntry) {
             if (!fileEntry || !_AUDIT_ASYNC_LANGS.has(fileEntry.language)) return;
             const language = fileEntry.language;
+            const indexedCalls = language === 'csharp'
+                ? index.getCachedCalls(filePath) || []
+                : [];
 
             // Collect async functions from the file's symbol list.
             // Also build a per-file set of names that are async in THIS file —
@@ -2465,7 +2521,7 @@ function auditAsync(index, options = {}) {
             let parser, content, tree;
             try {
                 if (language === 'html') {
-                    const htmlModule = getLanguageModule('html');
+                    const htmlModule = getLanguageAdapter('html');
                     const htmlParser = getParser('html');
                     const jsParser = getParser('javascript');
                     if (!htmlParser || !jsParser) return;
@@ -2484,7 +2540,10 @@ function auditAsync(index, options = {}) {
             if (!tree) return;
 
             // Walk every call_expression within an async function range.
-            const callTypes = new Set(['call_expression', 'call', 'method_invocation', 'object_creation_expression']);
+            const callTypes = new Set([
+                'call_expression', 'call', 'method_invocation',
+                'invocation_expression', 'object_creation_expression',
+            ]);
 
             // Function-boundary nodes per language (used to find the nearest
             // enclosing function and determine if IT is async — not just any
@@ -2495,6 +2554,8 @@ function auditAsync(index, options = {}) {
                 tsx:        new Set(['function_declaration', 'function_expression', 'arrow_function', 'method_definition', 'generator_function', 'generator_function_declaration', 'function_signature']),
                 html:       new Set(['function_declaration', 'function_expression', 'arrow_function', 'method_definition', 'generator_function', 'generator_function_declaration']),
                 python:     new Set(['function_definition', 'async_function_definition', 'lambda']),
+                csharp:     new Set(['method_declaration', 'local_function_statement',
+                    'anonymous_method_expression', 'lambda_expression']),
             }[language] || new Set();
 
             function isAsyncFnNode(node) {
@@ -2509,7 +2570,9 @@ function auditAsync(index, options = {}) {
                 // method_definition: scan first child for 'async' identifier.
                 for (let i = 0; i < node.namedChildCount; i++) {
                     const c = node.namedChild(i);
-                    if (c.type === 'async') return true;
+                    if (c.type === 'async' || (c.type === 'modifier' && c.text === 'async')) {
+                        return true;
+                    }
                 }
                 return false;
             }
@@ -2558,7 +2621,8 @@ function auditAsync(index, options = {}) {
                                 funcNode.type === 'selector_expression' || funcNode.type === 'field_expression') {
                                 const prop = funcNode.childForFieldName('property') ||
                                              funcNode.childForFieldName('field') ||
-                                             funcNode.childForFieldName('attribute');
+                                             funcNode.childForFieldName('attribute') ||
+                                             funcNode.childForFieldName('name');
                                 calleeName = prop ? prop.text : null;
                                 isMethodCall = true;
                             } else {
@@ -2575,7 +2639,31 @@ function auditAsync(index, options = {}) {
                                 // in unrelated.js — bad.js's helper() should
                                 // still be flagged).
                                 let calleeIsAsync;
-                                if (fileAsyncNames.has(calleeName)) {
+                                if (language === 'csharp') {
+                                    // C# method identity is nominal. Prefer the
+                                    // indexed receiver type at this call site;
+                                    // fall back only when every project
+                                    // definition with the name is async.
+                                    const indexed = indexedCalls.find(call =>
+                                        call.name === calleeName && call.line === line &&
+                                        call.isMethod === isMethodCall);
+                                    let receiverType = indexed?.receiverType || null;
+                                    if (!receiverType && indexed?.receiverField &&
+                                        indexed?.receiverRootType) {
+                                        const field = (fileEntry.symbols || []).find(symbol =>
+                                            symbol.type === 'field' &&
+                                            symbol.className === indexed.receiverRootType &&
+                                            symbol.name === indexed.receiverField);
+                                        receiverType = field?.fieldType || null;
+                                    }
+                                    const receiverDefs = receiverType
+                                        ? callableDefs(index.symbols.get(calleeName) || [])
+                                            .filter(def => def.className === receiverType)
+                                        : [];
+                                    calleeIsAsync = receiverDefs.length > 0
+                                        ? receiverDefs.every(isDefAsync)
+                                        : asyncNames.has(calleeName);
+                                } else if (fileAsyncNames.has(calleeName)) {
                                     calleeIsAsync = true;
                                 } else if (fileAnyDefNames.has(calleeName)) {
                                     // Same-file def exists and isn't async →
@@ -2595,7 +2683,7 @@ function auditAsync(index, options = {}) {
                                     // class's async `get`. Method-call audits
                                     // need a more sophisticated receiver
                                     // resolution that we don't have here.
-                                    if (isMethodCall) {
+                                    if (isMethodCall && language !== 'csharp') {
                                         // (Allow only when callee is in the
                                         // KNOWN_ASYNC_CALLEES list — those are
                                         // standard global functions, not
@@ -2606,12 +2694,34 @@ function auditAsync(index, options = {}) {
                                             // Fall through to common flag logic
                                         }
                                     }
-                                    if (!isMethodCall || _KNOWN_ASYNC_CALLEES.has(calleeName)) {
+                                    if (!isMethodCall || language === 'csharp' ||
+                                        _KNOWN_ASYNC_CALLEES.has(calleeName)) {
                                         // Check: is the call awaited?
                                         let awaited = false;
-                                        const p = node.parent;
-                                        if (p && (p.type === 'await_expression' || p.type === 'await')) {
-                                            awaited = true;
+                                        let current = node.parent;
+                                        let awaitDepth = 0;
+                                        while (current && awaitDepth++ < 5) {
+                                            if (current.type === 'await_expression' ||
+                                                current.type === 'await') {
+                                                awaited = true;
+                                                break;
+                                            }
+                                            // C#'s canonical
+                                            // `await Task().ConfigureAwait(false)`
+                                            // wraps the original invocation in
+                                            // a member-access + invocation
+                                            // chain before the await node.
+                                            if (language === 'csharp' && [
+                                                'member_access_expression',
+                                                'invocation_expression',
+                                                'conditional_access_expression',
+                                                'member_binding_expression',
+                                                'parenthesized_expression',
+                                            ].includes(current.type)) {
+                                                current = current.parent;
+                                                continue;
+                                            }
+                                            break;
                                         }
                                         if (!awaited && !isFireAndForget(node, language)) {
                                             issues.push({