Function analyzeDataFlow

src/context/data-flow.ts:83–177

(rel: string, content: string)

 * Best-effort: returns [] on parse failure / unsupported language.
 */
export async function analyzeDataFlow(rel: string, content: string): Promise<FunctionDataFlow[]> {
  const lang = detectLanguage(rel);
  if (!lang) return [];
  let parser;
  try { parser = await getParser(lang); } catch { return []; }
  if (!parser) return [];
  let tree;
  try { tree = parser.parser.parse(content); } catch { return []; }

  const results: FunctionDataFlow[] = [];

  const analyzeFunction = (fnNode: any) => {
    const declared = new Set<string>();
    collectParams(fnNode, content, declared);

    // First pass: gather locally-declared names so they don't count as free.
    const gatherDecls = (n: any) => {
      if (!n) return;
      if (LOCAL_DECL_RE.test(n.type)) {
        const nameNode = n.childForFieldName?.('name') ?? n.childForFieldName?.('left');
        if (nameNode && (nameNode.type === 'identifier')) {
          declared.add(content.slice(nameNode.startIndex, nameNode.endIndex));
        }
        // variable_declarator with destructuring / multiple
        for (let i = 0; i < (n.childCount ?? 0); i++) {
          const c = n.child(i);
          if (c?.type === 'identifier' && i === 0) {
            declared.add(content.slice(c.startIndex, c.endIndex));
          }
        }
      }
      // nested function params are declared in their own scope but we keep it
      // simple: treat them as declared so we don't over-report.
      if (FUNC_NODE_RE.test(n.type) && n !== fnNode) {
        collectParams(n, content, declared);
      }
      for (let i = 0; i < (n.childCount ?? 0); i++) gatherDecls(n.child(i));
    };
    const body = fnNode.childForFieldName?.('body') ?? fnNode;
    gatherDecls(body);

    // Second pass: count free identifiers (not declared, not a property key).
    const freq = new Map<string, number>();
    const walk = (n: any) => {
      if (!n) return;
      if (n.type === 'identifier') {
        const name = content.slice(n.startIndex, n.endIndex);
        // Allow single-char identifiers — they can be real function refs (g, _, $).
        // Only skip empty strings and pure noise: single underscores are common
        // throwaway vars, but we keep everything else including single letters.
        if (name.length >= 1 && name !== '_' && !declared.has(name) && !BUILTINS.has(name)) {
          freq.set(name, (freq.get(name) ?? 0) + 1);
        }
      } else if (n.type === 'member_expression') {
        // obj.property — only walk the OBJECT side (left); skip the property name (right).
        // Field names: object (left side), property (right side = what we skip).
        const obj = n.childForFieldName?.('object');
        if (obj) walk(obj);