Function handleAppResourceTuple

src/extraction/languages/erlang.ts:226–260

* OTP application resource file (` .app.src` / ` .app`): a single * `{application, Name, Props}.` term the grammar parses as a top-level * expression. Two properties carry graph structure — `{mod, {Mod, _Args}}` * names the application-callback module (the app's entry point), and * `{app

(node: SyntaxNode, ctx: ExtractorContext)

 * out-of-repo apps stay unresolved.
 */
function handleAppResourceTuple(node: SyntaxNode, ctx: ExtractorContext): boolean {
  const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
  const props = node.namedChildren[2];
  if (!parentId || props?.type !== 'list') return true;
  const ref = (nameNode: SyntaxNode, kind: 'references' | 'imports'): void => {
    const name = atomText(nameNode, ctx.source);
    if (!name) return;
    ctx.addUnresolvedReference({
      fromNodeId: parentId,
      referenceName: name,
      referenceKind: kind,
      line: nameNode.startPosition.row + 1,
      column: nameNode.startPosition.column,
    });
  };
  for (const prop of props.namedChildren) {
    if (prop.type !== 'tuple' || prop.namedChildren.length < 2) continue;
    const key = prop.namedChildren[0];
    const value = prop.namedChildren[1];
    if (!key || key.type !== 'atom' || !value) continue;
    const keyName = atomText(key, ctx.source);
    if (keyName === 'mod' && value.type === 'tuple') {
      const mod = value.namedChildren[0];
      if (mod?.type === 'atom') ref(mod, 'references');
    } else if (
      (keyName === 'applications' || keyName === 'included_applications') &&
      value.type === 'list'
    ) {
      for (const app of value.namedChildren) {
        if (app.type === 'atom') ref(app, 'imports');
      }
    }
  }
  return true; // nothing else in an app term carries graph structure
}

export const erlangExtractor: LanguageExtractor = {
  functionTypes: ['fun_decl'], // dispatched via visitNode (name lives on the clause)