enhance analyzer for callee chains

Author: skarim

README.md

@@ -9,7 +9,7 @@ Swift AST parsing in JavaScript via WebAssembly (WASM), powered by SwiftSyntax +
 This package compiles SwiftSyntax + SwiftParser to a WASI module and exposes a simple JavaScript API to parse Swift source into a compact JSON AST. On top of that, it provides a lightweight analyzer (inspired by Ruby Prism’s ergonomics) to:
 
 - extract declarations (functions, methods, classes, structs, enums, variables)
-- find and inspect function/method calls
+- find and inspect function/method calls (with callee chain and base identifier)
 - follow simple identifier references within lexical scope
 - surface naive type hints where present (e.g., `let x: Int`)
 
@@ -83,7 +83,13 @@ console.log([...analysis.byName.keys()]);
 // All calls to a function/method named "track"
 const calls = analysis.findCallsByName('track');
 for (const c of calls) {
-  console.log({ name: c.name, receiver: c.receiver, args: c.argsCount, at: c.range.start });
+  console.log({
+    name: c.name,
+    receiver: c.receiver,
+    base: c.baseIdentifier,
+    chain: c.calleeChain,
+    args: analysis.getCallArgs(c.id)
+  });
 }
 
 // Resolve a simple name to its symbol (best-effort)
@@ -105,8 +111,8 @@ type Analysis = {
 ```
 
 Notes:
-- The analyzer is syntax-driven (no full type-checker). Name resolution is lexical and best-effort.
-- Variable type annotations (e.g., `let x: Int`) are extracted where present; inferred types are not computed.
+- Syntax-driven only (no full type-checker). Name resolution is lexical and best-effort.
+- Exposes helpers to ease tracking analysis: labeled args, dictionary extraction, enclosing symbol lookup, const string collection, and callee text/chain utilities.
 
 ## CLI usage
 

src/analyze.ts

@@ -32,6 +32,8 @@ export type CallInfo = {
   argsCount: number;
   range: Range;
   refersToId?: number;
+  calleeChain?: string[];
+  baseIdentifier?: string;
 };
 
 export type RefInfo = {
@@ -41,11 +43,22 @@ export type RefInfo = {
   refersToId?: number;
 };
 
+export type CallArg = { label?: string; text: string; range: Range; nodeId: number };
+
 export type Analysis = {
   symbols: Map<number, SymbolInfo>;
   calls: CallInfo[];
   refs: RefInfo[];
   byName: Map<string, number[]>;
+  getNode: (id: number) => AstNode | undefined;
+  getChildren: (id: number) => number[];
+  getParent: (id: number) => number | undefined;
+  getCalleeText: (callId: number) => string | undefined;
+  getStringLiteralValue: (nodeId: number) => string | undefined;
+  getCallArgs: (callId: number) => CallArg[];
+  extractDictionary: (nodeId: number) => any;
+  findEnclosing: (nodeId: number, kinds?: string[]) => SymbolInfo | undefined;
+  collectConstStrings: () => Map<string, string>;
   findCallsByName: (name: string) => CallInfo[];
   resolveNameAt: (name: string, offset: number) => SymbolInfo | undefined;
 };
@@ -109,6 +122,83 @@ export function analyzeAst(ast: Ast, source: string): Analysis {
   const byName = new Map<string, number[]>();
   const calls: CallInfo[] = [];
   const refs: RefInfo[] = [];
+  const constStrings = new Map<string, string>();
+
+  const nodeAt = (id: number) => ast.nodes[id];
+  const kidsOf = (id: number) => children.get(id) ?? [];
+  const parentOf = (id: number) => parent.get(id);
+
+  function findDirectChildToken(id: number, token: string): number | undefined {
+    for (const k of kidsOf(id)) {
+      const n = nodeAt(k);
+      if (n && n.kind === 'TokenSyntax' && n.tokenText === token) return k;
+    }
+    return undefined;
+  }
+
+  function calleeTextForCall(id: number): string | undefined {
+    const node = nodeAt(id);
+    if (!node) return undefined;
+    const lparenId = findDirectChildToken(id, '(');
+    if (!lparenId) return undefined;
+    const lp = nodeAt(lparenId)!;
+    const start = node.range.start.offset;
+    const end = lp.range.start.offset; // up to the '(' that begins this call's arg list
+    return source.slice(start, end).trim();
+  }
+
+  function calleeChainParts(text: string): string[] {
+    if (!text) return [];
+    // Split on member separators, handling optional/force chaining
+    return text.split(/(?:\?\.|!\.|\.)/).map(s => s.trim()).filter(Boolean);
+  }
+
+  function baseIdentifierFromChain(chain: string[]): string | undefined {
+    if (!chain.length) return undefined;
+    const base = chain[0];
+    return base.replace(/[!?]+$/g, '').replace(/\(\)$/, '');
+  }
+
+  function splitTopLevel(input: string, sep: string): string[] {
+    const out: string[] = [];
+    let depthPar = 0, depthBr = 0, depthBr2 = 0;
+    let inStr = false, esc = false;
+    let acc = '';
+    for (let i = 0; i < input.length; i++) {
+      const ch = input[i];
+      if (inStr) {
+        acc += ch;
+        if (esc) { esc = false; continue; }
+        if (ch === '\\') { esc = true; continue; }
+        if (ch === '"') { inStr = false; }
+        continue;
+      }
+      if (ch === '"') { inStr = true; acc += ch; continue; }
+      if (ch === '(') depthPar++;
+      else if (ch === ')') depthPar = Math.max(0, depthPar - 1);
+      else if (ch === '[') depthBr++;
+      else if (ch === ']') depthBr = Math.max(0, depthBr - 1);
+      else if (ch === '{') depthBr2++;
+      else if (ch === '}') depthBr2 = Math.max(0, depthBr2 - 1);
+
+      if (ch === sep && depthPar === 0 && depthBr === 0 && depthBr2 === 0) {
+        out.push(acc);
+        acc = '';
+      } else {
+        acc += ch;
+      }
+    }
+    if (acc.trim() !== '') out.push(acc);
+    return out.map(s => s.trim());
+  }
+
+  function unquote(s: string): string {
+    if (s.startsWith('"') && s.endsWith('"')) {
+      const body = s.slice(1, -1);
+      return body.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\\\/g, '\\');
+    }
+    return s;
+  }
 
   // DFS with scope stack of maps: name -> symbolId
   const scopeStack: Array<Map<string, number>> = [new Map()];
@@ -158,11 +248,14 @@ export function analyzeAst(ast: Ast, source: string): Analysis {
 
     // Calls and references
     if (kind === 'FunctionCallExprSyntax') {
-      const text = slice(source, node.range);
-      const c = extractCallFromText(text);
+      const fullText = slice(source, node.range);
+      const c = extractCallFromText(fullText);
+      let calleeText = calleeTextForCall(id);
+      const chain = calleeText ? calleeChainParts(calleeText) : undefined;
+      const baseId = chain ? baseIdentifierFromChain(chain) : undefined;
       if (c) {
         const refersToId = resolveName(c.name);
-        calls.push({ id, name: c.name, receiver: c.receiver, argsCount: c.argsCount, range: node.range, refersToId });
+        calls.push({ id, name: c.name, receiver: c.receiver, argsCount: c.argsCount, range: node.range, refersToId, calleeChain: chain, baseIdentifier: baseId });
       }
     }
     if (kind === 'DeclReferenceExprSyntax') {
@@ -173,18 +266,132 @@ export function analyzeAst(ast: Ast, source: string): Analysis {
       refs.push({ id, name, range: node.range, refersToId });
     }
 
+    // Best-effort const strings: let NAME = "..."
+    if (kind === 'VariableDeclSyntax') {
+      const text = slice(source, node.range);
+      const m = text.match(/\blet\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=]+)?=\s*("(?:[^"\\]|\\.)*")/s);
+      if (m) {
+        constStrings.set(m[1], unquote(m[2]));
+      }
+    }
+
     for (const k of kids) walk(k);
 
     if (isScope(kind)) scopeStack.pop();
   }
 
   walk(ast.root);
 
+  function getCallArgs(callId: number): CallArg[] {
+    const call = nodeAt(callId);
+    if (!call || call.kind !== 'FunctionCallExprSyntax') return [];
+    const out: CallArg[] = [];
+    // Search shallow descendants up to depth 2 for labeled exprs
+    const level1 = kidsOf(callId);
+    const level2 = level1.flatMap(k => kidsOf(k));
+    const candidateIds = [...level1, ...level2];
+    for (const id of candidateIds) {
+      const n = nodeAt(id);
+      if (!n) continue;
+      if (n.kind === 'LabeledExprSyntax' || n.kind === 'TupleExprElementSyntax') {
+        const txt = slice(source, n.range);
+        const m = txt.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*/);
+        let label: string | undefined;
+        let valueStart = n.range.start.offset;
+        if (m) { label = m[1]; valueStart += m[0].length; }
+        const valueRange: Range = { start: { ...n.range.start, offset: valueStart }, end: n.range.end };
+        const valueText = source.slice(valueStart, n.range.end.offset).trim();
+        out.push({ label, text: valueText, range: valueRange, nodeId: id });
+      }
+    }
+    return out;
+  }
+
+  function parseValue(text: string): any {
+    const t = text.trim();
+    if (t.startsWith('"') && t.endsWith('"')) return unquote(t);
+    if (t === 'true') return true;
+    if (t === 'false') return false;
+    if (t === 'nil' || t === 'null') return null;
+    if (/^-?\d+(?:\.\d+)?$/.test(t)) return Number(t);
+    if (t.startsWith("[") && t.endsWith("]")) {
+      const inner = t.slice(1, -1);
+      const parts = splitTopLevel(inner, ',');
+      return parts.map(p => parseValue(p));
+    }
+    if (t.startsWith("[") && t.includes(":")) {
+      // dictionary fallback when we can't rely on kind
+      return parseDict(text);
+    }
+    return t; // fallback raw
+  }
+
+  function parseDict(text: string): any {
+    const body = text.trim().replace(/^\[/, '').replace(/\]$/, '');
+    const parts = splitTopLevel(body, ',');
+    const obj: any = {};
+    for (const part of parts) {
+      if (!part) continue;
+      const m = part.match(/^\s*("(?:[^"\\]|\\.)*")\s*:\s*([\s\S]*)$/);
+      if (!m) continue;
+      const key = unquote(m[1]);
+      const val = parseValue(m[2]);
+      obj[key] = val;
+    }
+    return obj;
+  }
+
+  function extractDictionary(nodeId: number): any {
+    const n = nodeAt(nodeId);
+    if (!n) return undefined;
+    const text = slice(source, n.range);
+    return parseDict(text);
+  }
+
+  function findEnclosing(nodeId: number, kinds?: string[]): SymbolInfo | undefined {
+    const set = new Set(kinds && kinds.length ? kinds : ['FunctionDeclSyntax','ClassDeclSyntax','StructDeclSyntax']);
+    let cur = parentOf(nodeId);
+    while (cur !== undefined) {
+      const n = nodeAt(cur);
+      if (n && set.has(n.kind)) {
+        const ids = byName.get(n.name ?? '') ?? [];
+        for (const id of ids) {
+          const s = symbols.get(id);
+          if (s && s.id === cur) return s;
+        }
+        // fallback if symbol map missed it
+        const k = classifyDeclKind(n.kind);
+        if (k && n.name) {
+          return { id: cur, kind: k, name: n.name, range: n.range, parentId: parentOf(cur) };
+        }
+      }
+      cur = parentOf(cur!);
+    }
+    return undefined;
+  }
+
+  function getStringLiteralValue(nodeId: number): string | undefined {
+    const n = nodeAt(nodeId);
+    if (!n) return undefined;
+    const t = slice(source, n.range).trim();
+    if (t.startsWith('"') && t.endsWith('"')) return unquote(t);
+    return undefined;
+  }
+
   return {
     symbols,
     calls,
     refs,
     byName,
+    getNode: (id: number) => nodeAt(id),
+    getChildren: (id: number) => kidsOf(id),
+    getParent: (id: number) => parentOf(id),
+    getCalleeText: (callId: number) => calleeTextForCall(callId),
+    getStringLiteralValue,
+    getCallArgs,
+    extractDictionary,
+    findEnclosing,
+    collectConstStrings: () => constStrings,
     findCallsByName: (name: string) => calls.filter(c => c.name === name),
     resolveNameAt: (name: string, _offset: number) => {
       const ids = byName.get(name);

tests/analyze.test.ts

@@ -6,19 +6,7 @@ import { parseSwiftAst, analyzeAst } from '../dist/index.js';
 
 const FIX_DIR = join(process.cwd(), 'tests', 'fixtures');
 const FILE = join(FIX_DIR, 'analyze.swift');
-
-const SOURCE = `
-struct Foo {
-  let x: Int
-  func bar(_ y: Int) -> Int { x + y }
-}
-
-func bar(_ n: Int) -> Int { n * 2 }
-
-let a = Foo()
-let b = bar(3)
-let c = a.bar(4)
-`;
+const SOURCE = await fs.readFile(FILE, 'utf8');
 
 await fs.mkdir(FIX_DIR, { recursive: true });
 await fs.writeFile(FILE, SOURCE, 'utf8');
@@ -38,4 +26,21 @@ test('analyzeAst extracts symbols and calls', async () => {
   // At least one receiver-less and one with receiver
   assert.ok(callsBar.some(c => !c.receiver));
   assert.ok(callsBar.some(c => c.receiver === 'a'));
+
+  // Callee chain
+  const callInst = callsBar.find(c => c.receiver === 'a');
+  assert.ok(callInst?.calleeChain && callInst.calleeChain.at(-1) === 'bar');
+
+  // Args
+  if (callInst) {
+    const args = analysis.getCallArgs(callInst.id);
+    assert.ok(Array.isArray(args));
+  }
+
+  // Enclosing function for a global call should be undefined or global
+  const globalCall = callsBar.find(c => !c.receiver);
+  if (globalCall) {
+    const enc = analysis.findEnclosing(globalCall.id);
+    assert.ok(!enc || enc.kind === 'function');
+  }
 });

tests/fixtures/analyze.swift

@@ -0,0 +1,10 @@
+struct Foo {
+  let x: Int
+  func bar(_ y: Int) -> Int { x + y }
+}
+
+func bar(_ n: Int) -> Int { n * 2 }
+
+let a = Foo()
+let b = bar(3)
+let c = a.bar(4)

tests/fixtures/simple.swift

@@ -1,4 +1,3 @@
-
 struct Foo {
   let x: Int
   func bar(_ y: Int) -> Int { x + y }