Function handleFunDecl

src/extraction/languages/erlang.ts:99–143

(node: SyntaxNode, ctx: ExtractorContext)

}

function handleFunDecl(node: SyntaxNode, ctx: ExtractorContext): boolean {
  const clauses = node.namedChildren.filter((c) => c.type === 'function_clause');
  const first = clauses[0];
  if (!first) return true; // macro-templated clause (`?M(...) -> ...`) — no static name
  const nameNode = getChildByField(first, 'name');
  if (!nameNode) return true;
  const name = atomText(nameNode, ctx.source);
  if (!name) return true;

  // Continuation clause: extend the existing node's span and attribute this
  // clause's calls to it.
  if (ctx.filePath === lastFnFile && name === lastFnName && lastFnId) {
    for (let i = ctx.nodes.length - 1; i >= 0; i--) {
      const n = ctx.nodes[i];
      if (n && n.id === lastFnId) {
        if (node.endPosition.row + 1 > n.endLine) n.endLine = node.endPosition.row + 1;
        break;
      }
    }
    ctx.pushScope(lastFnId);
    for (const clause of clauses) ctx.visitFunctionBody(clause, lastFnId);
    ctx.popScope();
    return true;
  }

  const spec = precedingSpec(node, name, ctx.source);
  const exports = moduleExports(node, ctx.source, ctx.filePath);
  const fn = ctx.createNode('function', name, node, {
    docstring: getPrecedingDocstring(spec ?? node, ctx.source),
    signature: spec
      ? collapseWs(getNodeText(spec, ctx.source)).slice(0, 300)
      : clauseHeader(first, ctx.source),
    isExported: exports === 'all' || exports.has(name),
  });
  if (!fn) return true;
  ctx.pushScope(fn.id);
  // The whole clause is walked (not just the body) so record patterns in the
  // arguments and guard calls contribute references too.
  for (const clause of clauses) ctx.visitFunctionBody(clause, fn.id);
  ctx.popScope();
  lastFnFile = ctx.filePath;
  lastFnName = name;
  lastFnId = fn.id;
  return true;
}

function handleRecordDecl(node: SyntaxNode, ctx: ExtractorContext): boolean {
  const nameNode = getChildByField(node, 'name');