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

@@ -166,3 +166,17 @@ function processSwitchlike(switchSyntax: SyntaxNode, ctx: Context): BasicBlock {
 
   return blockHandler.update({ entry: headNode, exit: mergeNode });
 }
+
+const nodeType = {
+  functionDefinition: "function_definition",
+
+  // identifier lookups
+  identifier: "identifier",
+};
+
+export function extractCFunctionName(func: SyntaxNode): string | undefined {
+  if (func.type === nodeType.functionDefinition) {
+    return func.descendantsOfType(nodeType.identifier)[0]?.text;
+  }
+  return undefined;
+}

src/control-flow/cfg-cpp.ts

@@ -7,6 +7,7 @@ import {
   processReturnStatement,
   processThrowStatement,
 } from "./common-patterns.ts";
+import { extractNameByNodeType } from "./function-utils.ts";
 import {
   type Context,
   GenericCFGBuilder,
@@ -148,3 +149,72 @@ function processTryStatement(trySyntax: SyntaxNode, ctx: Context): BasicBlock {
     });
   });
 }
+
+const nodeType = {
+  functionDefinition: "function_definition",
+  lambdaExpression: "lambda_expression",
+
+  // inline/function‑assignment cases
+  variableDeclaration: "variable_declaration",
+  initDeclarator: "init_declarator",
+
+  // identifier lookups
+  identifier: "identifier",
+
+  //Unnamed functions
+  anonymous: "<anonymous>",
+
+  //Special cases , operator-name and destructor-name
+  operatorName: "operator_name",
+  destructorName: "destructor_name",
+};
+
+function findCppNameInParentHierarchy(
+  func: SyntaxNode,
+  parentType: string,
+  childType: string,
+): string | undefined {
+  let parent = func.parent;
+  while (parent) {
+    if (parent.type === parentType) {
+      return extractNameByNodeType(parent, childType);
+    }
+    parent = parent.parent;
+  }
+  return undefined;
+}
+
+export function extractCppFunctionName(func: SyntaxNode): string | undefined {
+  if (func.type === nodeType.functionDefinition) {
+    // Look for an operator overload (This should happen before the identifier/destructor).
+    const operatorNode = func.descendantsOfType(nodeType.operatorName)[0];
+    if (operatorNode) return operatorNode.text;
+
+    // else, look for the destructor name, which is a special case because identifier returns without the ~
+    const destructorNode = func.descendantsOfType(nodeType.destructorName)[0];
+    if (destructorNode) {
+      return destructorNode.text;
+    }
+    //if neither of those, look for the identifier
+    const idNode = func.descendantsOfType(nodeType.identifier)[0];
+    if (idNode) return idNode.text;
+  }
+  if (func.type === nodeType.lambdaExpression) {
+    // if the lambda is assigned to a variable, return the variable name
+    // otherwise return "<Anonymous>"
+    return (
+      findCppNameInParentHierarchy(
+        func,
+        nodeType.variableDeclaration,
+        nodeType.identifier,
+      ) ||
+      findCppNameInParentHierarchy(
+        func,
+        nodeType.initDeclarator,
+        nodeType.identifier,
+      ) ||
+      nodeType.anonymous
+    );
+  }
+  return undefined;
+}

src/control-flow/cfg-go.ts

@@ -12,6 +12,10 @@ import {
   processReturnStatement,
   processStatementSequence,
 } from "./common-patterns.ts";
+import {
+  extractNameByNodeType,
+  extractTaggedValueFromTreeSitterQuery,
+} from "./function-utils.ts";
 import {
   type Context,
   GenericCFGBuilder,
@@ -419,3 +423,75 @@ function processSwitchlike(
 
   return blockHandler.update({ entry: headNode, exit: mergeNode });
 }
+
+const nodeType = {
+  // Function-related node types
+  functionDeclaration: "function_declaration",
+  methodDeclaration: "method_declaration",
+  funcLiteral: "func_literal",
+
+  // identifier lookups
+  identifier: "identifier",
+  fieldIdentifier: "field_identifier",
+
+  // Unnamed functions
+  anonymous: "<anonymous>",
+};
+
+const shortVarQueryAndTag = {
+  query: `
+    (short_var_declaration
+      left: (expression_list
+        (identifier) @var.name))
+  `,
+  tag: "var.name",
+};
+
+const varDeclarationQueryAndTag = {
+  query: `
+    (var_declaration
+      (var_spec
+        (identifier) @var.name))
+  `,
+  tag: "var.name",
+};
+
+const assignmentQueryAndTag = {
+  query: `
+    (assignment_statement
+      left: (expression_list
+        (identifier) @var.name))
+  `,
+  tag: "var.name",
+};
+
+export function extractGoFunctionName(func: SyntaxNode): string | undefined {
+  switch (func.type) {
+    case nodeType.functionDeclaration:
+      return extractNameByNodeType(func, nodeType.identifier);
+    case nodeType.methodDeclaration:
+      return extractNameByNodeType(func, nodeType.fieldIdentifier);
+    case nodeType.funcLiteral:
+      // Check if the func_literal is assigned to a variable or is a standalone function
+      return (
+        extractTaggedValueFromTreeSitterQuery(
+          func,
+          shortVarQueryAndTag.query,
+          shortVarQueryAndTag.tag,
+        ) ||
+        extractTaggedValueFromTreeSitterQuery(
+          func,
+          varDeclarationQueryAndTag.query,
+          varDeclarationQueryAndTag.tag,
+        ) ||
+        extractTaggedValueFromTreeSitterQuery(
+          func,
+          assignmentQueryAndTag.query,
+          assignmentQueryAndTag.tag,
+        ) ||
+        nodeType.anonymous
+      );
+    default:
+      return undefined;
+  }
+}

src/control-flow/cfg-python.ts

@@ -6,6 +6,7 @@ import {
   forEachLoopProcessor,
   processStatementSequence,
 } from "./common-patterns.ts";
+import { extractNameByNodeType } from "./function-utils.ts";
 import {
   type Context,
   GenericCFGBuilder,
@@ -624,3 +625,19 @@ function processWhileStatement(
 
   return matcher.update({ entry: condBlock.entry, exit: exitNode });
 }
+
+const nodeType = {
+  functionDefinition: "function_definition",
+
+  // identifier lookups
+  identifier: "identifier",
+};
+
+export function extractPythonFunctionName(
+  func: SyntaxNode,
+): string | undefined {
+  if (func.type === nodeType.functionDefinition) {
+    return extractNameByNodeType(func, nodeType.identifier);
+  }
+  return undefined;
+}

src/control-flow/cfg-typescript.ts

@@ -17,6 +17,10 @@ import {
   processStatementSequence,
   processThrowStatement,
 } from "./common-patterns.ts";
+import {
+  extractNameByNodeType,
+  extractTaggedValueFromTreeSitterQuery,
+} from "./function-utils.ts";
 import {
   type Context,
   GenericCFGBuilder,
@@ -319,3 +323,82 @@ function processTryStatement(trySyntax: SyntaxNode, ctx: Context): BasicBlock {
     });
   });
 }
+
+const nodeType = {
+  // function‑declaration cases
+  functionDeclaration: "function_declaration",
+  generatorFunctionDeclaration: "generator_function_declaration",
+
+  // inline/function‑expression cases
+  generatorFunction: "generator_function",
+  arrowFunction: "arrow_function",
+  functionExpression: "function_expression",
+
+  // methods
+  methodDefinition: "method_definition",
+
+  // identifier lookups
+  identifier: "identifier",
+  propertyIdentifier: "property_identifier",
+
+  // Unnamed functions
+  anonymous: "<anonymous>",
+};
+
+const variableDeclaratorQueryAndTag = {
+  query: `
+    (lexical_declaration
+      (variable_declarator
+        name: (identifier) @var.name))
+  `,
+  tag: "var.name",
+};
+
+/**
+ * Extracts the name of a TypeScript function based on its syntax node type.
+ *
+ * @param {SyntaxNode} func - The syntax node representing the TypeScript function.
+ * @returns {string | undefined} The function name, or `undefined` if not found.
+ */
+export function extractTypeScriptFunctionName(
+  func: SyntaxNode,
+): string | undefined {
+  switch (func.type) {
+    case nodeType.functionDeclaration:
+    case nodeType.generatorFunctionDeclaration:
+      return extractNameByNodeType(func, nodeType.identifier);
+
+    case nodeType.generatorFunction:
+    case nodeType.arrowFunction:
+      return (
+        extractTaggedValueFromTreeSitterQuery(
+          func,
+          variableDeclaratorQueryAndTag.query,
+          variableDeclaratorQueryAndTag.tag,
+        ) || nodeType.anonymous
+      );
+
+    case nodeType.methodDefinition:
+      return extractNameByNodeType(func, nodeType.propertyIdentifier);
+
+    case nodeType.functionExpression: {
+      // first check for a direct name
+      const optionalIdentifier = extractNameByNodeType(
+        func,
+        nodeType.identifier,
+      );
+      if (optionalIdentifier) return optionalIdentifier;
+
+      // otherwise fall back to a variable‑assignment name
+      return (
+        extractTaggedValueFromTreeSitterQuery(
+          func,
+          variableDeclaratorQueryAndTag.query,
+          variableDeclaratorQueryAndTag.tag,
+        ) || nodeType.anonymous
+      );
+    }
+    default:
+      return undefined;
+  }
+}