Merge pull request #134 from AlonBilman/issue#94

Adding function information to the /render page

Author: tmr232

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

CONTRIBUTORS.md

@@ -6,4 +6,6 @@ The following people have contributed to the development of Function-Graph-Overv
 
 - [Tamir Bahar](https://github.com/tmr232)
 - [Niv Baumel](https://github.com/Nivb1569)
+- [Alon Bilman](https://github.com/AlonBilman)  
+- [Ben Nahmias](https://github.com/Bennahmias)
 - [buherator](https://github.com/v-p-b)

src/control-flow/cfg-c.ts

@@ -20,12 +20,14 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { treeSitterNoNullNodes } from "./hacks.ts";
+import { extractCapturedTextsByCaptureName } from "./query-utils.ts";
 import { buildSwitch, collectCases } from "./switch-utils.ts";
 
 export const cLanguageDefinition = {
   wasmPath: treeSitterC,
   createCFGBuilder: createCFGBuilder,
   functionNodeTypes: ["function_definition"],
+  extractFunctionName: extractCFunctionName,
 };
 
 function getChildFieldText(node: SyntaxNode, fieldName: string): string {
@@ -166,3 +168,39 @@ function processSwitchlike(switchSyntax: SyntaxNode, ctx: Context): BasicBlock {
 
   return blockHandler.update({ entry: headNode, exit: mergeNode });
 }
+
+const functionQuery = {
+  functionDeclarator: `(function_declarator
+	  declarator:(identifier)@name)`,
+
+  captureName: "name",
+};
+
+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,
+  );
+
+  const declaratorNode = nodes.find((node) => {
+    const decl = node?.childForFieldName("declarator");
+    return decl?.type === "identifier";
+  });
+
+  return declaratorNode ?? null;
+}
+
+function extractCFunctionName(func: SyntaxNode): string | undefined {
+  const declarator = getFunctionDeclarator(func);
+  if (!declarator) return undefined;
+
+  return extractCapturedTextsByCaptureName(
+    declarator,
+    functionQuery.functionDeclarator,
+    functionQuery.captureName,
+  )[0];
+}

src/control-flow/cfg-cpp.ts

@@ -13,11 +13,13 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { pairwise, zip } from "./itertools.ts";
+import { extractCapturedTextsByCaptureName } from "./query-utils.ts";
 
 export const cppLanguageDefinition = {
   wasmPath: treeSitterCpp,
   createCFGBuilder: createCFGBuilder,
   functionNodeTypes: ["function_definition", "lambda_expression"],
+  extractFunctionName: extractCppFunctionName,
 };
 
 export function createCFGBuilder(options: BuilderOptions): CFGBuilder {
@@ -148,3 +150,113 @@ function processTryStatement(trySyntax: SyntaxNode, ctx: Context): BasicBlock {
     });
   });
 }
+
+const functionQuery = {
+  functionDeclarator: `
+    (function_declarator
+    declarator: [
+      (identifier)        		
+      (type_identifier)   		
+      (destructor_name)   		
+      (operator_name)     		
+      (operator_cast)     		
+      (field_identifier)  		
+      (qualified_identifier)	
+    ] @name )
+`,
+
+  initDeclarator: `
+   (init_declarator
+      declarator: (_) @name)
+  `,
+
+  captureName: "name",
+};
+
+const validDeclaratorTypes = new Set([
+  "identifier",
+  "operator_name",
+  "operator_cast",
+  "destructor_name",
+  "qualified_identifier",
+  "type_identifier",
+  "field_identifier",
+]);
+
+/**
+ * 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 && validDeclaratorTypes.has(decl.type)) {
+      return node;
+    }
+  }
+
+  return null;
+}
+
+function extractCppFunctionName(func: SyntaxNode): string | undefined {
+  if (func.type === "function_definition") {
+    const declarator = getFunctionDeclarator(func);
+    const name = declarator
+      ? extractCapturedTextsByCaptureName(
+          declarator,
+          functionQuery.functionDeclarator,
+          functionQuery.captureName,
+        )[0]
+      : undefined;
+    if (name) return name;
+
+    //From my observations, the only functions that do not have a function_declarator child are conversion operators.
+    //To extract their names, I need to manipulate strings (not ideal, but it works).
+    const fullDeclarationName = func.childForFieldName("declarator");
+    return fullDeclarationName?.text.split("(")[0];
+  }
+
+  if (func.type === "lambda_expression") {
+    const name = findVariableBinding(func);
+    return name;
+  }
+  return undefined;
+}
+
+// Find the binding variable of a lambda function
+function findVariableBinding(func: SyntaxNode): string | undefined {
+  const parent = func.parent;
+  if (!parent) return undefined;
+
+  switch (parent.type) {
+    // x = <func> -> "x" (identifier)
+    // x.field = <func> -> "x.field" (field_expression)
+    case "assignment_expression": {
+      const name = parent.childForFieldName("left");
+      console.log(name?.type);
+      return name?.type === "identifier" || name?.type === "field_expression"
+        ? name.text
+        : undefined;
+    }
+    // <type> x = <func> -> "x"
+    case "init_declarator":
+      return extractCapturedTextsByCaptureName(
+        parent,
+        functionQuery.initDeclarator,
+        functionQuery.captureName,
+      )[0];
+
+    default:
+      return undefined;
+  }
+}

src/control-flow/cfg-go.ts

@@ -18,6 +18,7 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder";
 import { treeSitterNoNullNodes } from "./hacks.ts";
+import { extractCapturedTextsByCaptureName } from "./query-utils.ts";
 import { type SwitchOptions, buildSwitch, collectCases } from "./switch-utils";
 
 export const goLanguageDefinition = {
@@ -28,6 +29,7 @@ export const goLanguageDefinition = {
     "method_declaration",
     "func_literal",
   ],
+  extractFunctionName: extractGoFunctionName,
 };
 
 const processBreakStatement = labeledBreakProcessor(`
@@ -419,3 +421,118 @@ 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
+      ]))`,
+
+  captureName: "name",
+};
+
+// Find the variable or field name bound to a function literal
+function findVariableBinding(func: SyntaxNode): string | undefined {
+  const parent = func.parent;
+  if (!parent) return undefined;
+
+  // 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 => {
+    const index = right.namedChildren.findIndex(
+      (child) => child?.type === "func_literal" && child.id === funcNode.id,
+    );
+
+    if (index !== -1) {
+      return index;
+    }
+    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 undefined.
+  const bindFromPair = (
+    node: SyntaxNode,
+    leftPattern: string,
+    rightField: "right" | "value" = "right",
+  ): string | undefined => {
+    const left = extractCapturedTextsByCaptureName(
+      node,
+      leftPattern,
+      functionQuery.captureName,
+    );
+    const right = node.childForFieldName(rightField);
+    if (!right) return undefined;
+
+    const bindingIndex = findFuncIndex(func, right);
+    if (bindingIndex !== null) {
+      return left[bindingIndex] ?? undefined;
+    }
+    return undefined;
+  };
+
+  switch (parent.parent?.type) {
+    // := short var declaration
+    case "short_var_declaration":
+      return bindFromPair(
+        parent.parent,
+        functionQuery.shortVarDeclaration,
+        "right",
+      );
+
+    // = plain assignment ...
+    case "assignment_statement":
+      return bindFromPair(
+        parent.parent,
+        functionQuery.assignmentStatement,
+        "right",
+      );
+
+    // var x, y = ..., func(){}, ...
+    // Same idea, but Go’s var spec uses "value".
+    case "var_spec":
+      return bindFromPair(parent.parent, functionQuery.varSpec, "value");
+
+    default:
+      return undefined;
+  }
+}
+
+function extractGoFunctionName(func: SyntaxNode): string | undefined {
+  switch (func.type) {
+    case "function_declaration":
+      return extractCapturedTextsByCaptureName(
+        func,
+        functionQuery.functionDeclaration,
+        functionQuery.captureName,
+      )[0];
+    case "method_declaration":
+      return extractCapturedTextsByCaptureName(
+        func,
+        functionQuery.methodDeclaration,
+        functionQuery.captureName,
+      )[0];
+    case "func_literal":
+      return findVariableBinding(func);
+    default:
+      return undefined;
+  }
+}

src/control-flow/cfg-python.ts

@@ -12,11 +12,13 @@ import {
   type StatementHandlers,
 } from "./generic-cfg-builder.ts";
 import { maybe, zip } from "./itertools.ts";
+import { extractCapturedTextsByCaptureName } from "./query-utils.ts";
 
 export const pythonLanguageDefinition = {
   wasmPath: treeSitterPython,
   createCFGBuilder: createCFGBuilder,
   functionNodeTypes: ["function_definition"],
+  extractFunctionName: extractPythonFunctionName,
 };
 const processForStatement = forEachLoopProcessor({
   query: `
@@ -624,3 +626,18 @@ function processWhileStatement(
 
   return matcher.update({ entry: condBlock.entry, exit: exitNode });
 }
+
+const functionQuery = {
+  functionDefinition: `(function_definition
+	  name :(identifier) @name)`,
+
+  captureName: "name",
+};
+
+function extractPythonFunctionName(func: SyntaxNode): string | undefined {
+  return extractCapturedTextsByCaptureName(
+    func,
+    functionQuery.functionDefinition,
+    functionQuery.captureName,
+  )[0];
+}