Adding function information to the /render page

CHANGELOG.md

@@ -6,6 +6,13 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+### Added
+
+- Function name extraction with support for multiple programming languages. 
+- Unit tests for function name extraction, covering various structures and languages.
+- Frontend logic in `render/src/App.svelte` to extract and display metadata based on render type. 
+- Display of both CFG and function metadata in the GitHub render view, and CFG metadata in the Graph render view.
+
 ## [0.0.16] - 2025-05-07
 
 ### Added

src/control-flow/cfg-c.ts

@@ -20,6 +20,7 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { treeSitterNoNullNodes } from "./hacks.ts";
+import { extractTaggedValueFromTreeSitterQuery } from "./query-utils.ts";
 import { buildSwitch, collectCases } from "./switch-utils.ts";
 
 export const cLanguageDefinition = {
@@ -166,3 +167,19 @@ function processSwitchlike(switchSyntax: SyntaxNode, ctx: Context): BasicBlock {
 
   return blockHandler.update({ entry: headNode, exit: mergeNode });
 }
+
+const functionQuery = {
+  functionDeclarator: `(function_declarator
+	  declarator:(identifier)@name)`,
+
+  tag: "name",
+};
+
+export function extractCFunctionName(func: SyntaxNode): string | undefined {
+  const name = extractTaggedValueFromTreeSitterQuery(
+    func,
+    functionQuery.functionDeclarator,
+    functionQuery.tag,
+  );
+  return name.length > 1 ? undefined : name[0];
+}

src/control-flow/cfg-cpp.ts

@@ -13,6 +13,7 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { pairwise, zip } from "./itertools.ts";
+import { extractTaggedValueFromTreeSitterQuery } from "./query-utils.ts";
 
 export const cppLanguageDefinition = {
   wasmPath: treeSitterCpp,
@@ -148,3 +149,93 @@ function processTryStatement(trySyntax: SyntaxNode, ctx: Context): BasicBlock {
     });
   });
 }
+
+const functionQuery = {
+  functionDeclarator: `
+   (function_declarator
+    declarator: [
+      (identifier)        @name
+      (type_identifier)   @name
+      (destructor_name)   @name
+      (operator_name)     @name
+      (operator_cast)     @name
+      (field_identifier)  @name
+      (qualified_identifier
+        name: [
+          (identifier)        @name
+          (type_identifier)   @name
+          (destructor_name)   @name
+          (operator_name)     @name
+          (operator_cast)     @name
+        ])
+    ])
+`,
+  functionDefinitionOperator: `
+(function_definition
+  declarator: (operator_cast
+    (_) @type))   
+
+(function_definition
+  declarator: (qualified_identifier
+    name: (operator_cast
+      (_) @type)))`,
+
+  name: "name",
+
+  type: "type",
+};
+
+/**
+ * Get the function_declarator node for a function_definition.
+ * Uses descendantsOfType to find it directly, even if wrapped
+ * in pointer/reference/parenthesized declarators.
+ */
+function getFunctionDeclarator(funcDef: SyntaxNode): SyntaxNode | null {
+  const body = funcDef.childForFieldName("body");
+  const end = body ? body.startPosition : funcDef.endPosition;
+
+  const nodes = funcDef.descendantsOfType(
+    "function_declarator",
+    funcDef.startPosition,
+    end,
+  );
+
+  for (const node of nodes) {
+    const decl = node?.childForFieldName("declarator");
+    if (
+      decl &&
+      (decl.type === "identifier" ||
+        decl.type === "operator_name" ||
+        decl.type === "operator_cast" ||
+        decl.type === "destructor_name" ||
+        decl.type === "qualified_identifier" ||
+        decl.type === "type_identifier" ||
+        decl.type === "field_identifier")
+    ) {
+      return node;
+    }
+  }
+
+  return null;
+}
+
+export function extractCppFunctionName(func: SyntaxNode): string | undefined {
+  if (func.type !== "function_definition") return undefined; //Just for now...
+
+  const declarator = getFunctionDeclarator(func);
+  const name = declarator
+    ? extractTaggedValueFromTreeSitterQuery(
+        declarator,
+        functionQuery.functionDeclarator,
+        functionQuery.name,
+      )[0]
+    : undefined;
+  if (name) return name;
+
+  const type = extractTaggedValueFromTreeSitterQuery(
+    func,
+    functionQuery.functionDefinitionOperator,
+    functionQuery.type,
+  )[0];
+  return type ? `operator ${type}` : undefined;
+}

src/control-flow/cfg-go.ts

@@ -18,6 +18,7 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder";
 import { treeSitterNoNullNodes } from "./hacks.ts";
+import { extractTaggedValueFromTreeSitterQuery } from "./query-utils.ts";
 import { type SwitchOptions, buildSwitch, collectCases } from "./switch-utils";
 
 export const goLanguageDefinition = {
@@ -419,3 +420,113 @@ function processSwitchlike(
 
   return blockHandler.update({ entry: headNode, exit: mergeNode });
 }
+
+const functionQuery = {
+  functionDeclaration: `(function_declaration
+	  name :(identifier) @name)`,
+
+  methodDeclaration: `(method_declaration
+	  name: (field_identifier) @name)`,
+
+  shortVarDeclaration: `(short_var_declaration
+    left: (expression_list (identifier) @name))`,
+
+  varSpec: `(var_spec
+    name: (identifier) @name)`,
+
+  assignmentStatement: `(assignment_statement
+  left: (expression_list
+    [
+      (identifier) @name
+      (selector_expression) @name
+    ]))`,
+
+  name: "name",
+};
+
+function findVariableBinding(func: SyntaxNode): string {
+  const parent = func.parent;
+  const anonymous = "<anonymous>";
+  if (!parent) return anonymous;
+
+  // Walk the right-hand expression list and find the index of *this* func literal.
+  // I compare by node id to be safe — same node, same id.
+  const findFuncIndex = (
+    funcNode: SyntaxNode,
+    right: SyntaxNode,
+  ): number | null => {
+    for (let i = 0; i < right.namedChildCount; i++) {
+      const child = right.namedChild(i);
+      if (child?.type === "func_literal" && child.id === funcNode.id) return i;
+    }
+    return null;
+  };
+
+  // We run the left query -> get names[], locate our func literal on the right -> get index,
+  // then names[index] is the binding.
+  // If nothing matches, return "<anonymous>".
+  const bindFromPair = (
+    node: SyntaxNode,
+    leftPattern: string,
+    rightField: "right" | "value" = "right",
+  ): string => {
+    const left = extractTaggedValueFromTreeSitterQuery(
+      node,
+      leftPattern,
+      functionQuery.name,
+    );
+    const right = node.childForFieldName(rightField);
+    if (!right) return anonymous;
+
+    const foundIndex = findFuncIndex(func, right);
+    return foundIndex !== null ? (left[foundIndex] ?? anonymous) : anonymous;
+  };
+
+  // := short var declaration
+  if (parent.parent?.type === "short_var_declaration") {
+    return bindFromPair(
+      parent.parent,
+      functionQuery.shortVarDeclaration,
+      "right",
+    );
+  }
+
+  // = plain assignment ...
+  if (parent.parent?.type === "assignment_statement") {
+    return bindFromPair(
+      parent.parent,
+      functionQuery.assignmentStatement,
+      "right",
+    );
+  }
+
+  // var x, y = ..., func(){}, ...
+  // Same idea, but Go’s var spec uses "value".
+  if (parent.parent?.type === "var_spec") {
+    return bindFromPair(parent.parent, functionQuery.varSpec, "value");
+  }
+
+  // If we got here, we didn’t find a binding in the supported contexts.
+  return anonymous;
+}
+
+export function extractGoFunctionName(func: SyntaxNode): string | undefined {
+  switch (func.type) {
+    case "function_declaration":
+      return extractTaggedValueFromTreeSitterQuery(
+        func,
+        functionQuery.functionDeclaration,
+        functionQuery.name,
+      )[0];
+    case "method_declaration":
+      return extractTaggedValueFromTreeSitterQuery(
+        func,
+        functionQuery.methodDeclaration,
+        functionQuery.name,
+      )[0];
+    case "func_literal":
+      return findVariableBinding(func);
+    default:
+      return undefined;
+  }
+}

src/control-flow/cfg-python.ts

@@ -12,6 +12,7 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { maybe, zip } from "./itertools.ts";
+import { extractTaggedValueFromTreeSitterQuery } from "./query-utils.ts";
 
 export const pythonLanguageDefinition = {
   wasmPath: treeSitterPython,
@@ -624,3 +625,21 @@ function processWhileStatement(
 
   return matcher.update({ entry: condBlock.entry, exit: exitNode });
 }
+
+const functionQuery = {
+  functionDefinition: `(function_definition
+	    name :(identifier)@name)`,
+
+  tag: "name",
+};
+
+export function extractPythonFunctionName(
+  func: SyntaxNode,
+): string | undefined {
+  const name = extractTaggedValueFromTreeSitterQuery(
+    func,
+    functionQuery.functionDefinition,
+    functionQuery.tag,
+  );
+  return name.length > 1 ? undefined : name[0];
+}