Separated function definition and signature

Author: LeBoufty

packages/cli/src/languagePlugins/c/dependencyFormatting/index.ts

@@ -1,11 +1,17 @@
-import { CDependency, CDepFile, CDepSymbol } from "./types.js";
+import {
+  C_DEP_FUNCTION_TYPE,
+  CDependency,
+  CDepFile,
+  CDepSymbol,
+  CDepSymbolType,
+} from "./types.js";
 import { CSymbolRegistry } from "../symbolRegistry/index.js";
 import { CIncludeResolver } from "../includeResolver/index.js";
 import { CInvocationResolver } from "../invocationResolver/index.js";
 import { CFile, Symbol } from "../symbolRegistry/types.js";
 import { Invocations } from "../invocationResolver/types.js";
 import Parser from "tree-sitter";
-import { SymbolType } from "../headerResolver/types.js";
+import { C_VARIABLE_TYPE, SymbolType } from "../headerResolver/types.js";
 
 export class CDependencyFormatter {
   symbolRegistry: CSymbolRegistry;
@@ -22,6 +28,22 @@ export class CDependencyFormatter {
     this.invocationResolver = new CInvocationResolver(this.includeResolver);
   }
 
+  #formatSymbolType(st: SymbolType): CDepSymbolType {
+    if (["struct", "enum", "union", "typedef", "variable"].includes(st)) {
+      return st as CDepSymbolType;
+    }
+    if (
+      ["function_signature", "function_definition", "macro_function"].includes(
+        st,
+      )
+    ) {
+      return C_DEP_FUNCTION_TYPE;
+    }
+    if (st === "macro_constant") {
+      return C_VARIABLE_TYPE as CDepSymbolType;
+    }
+  }
+
   /**
    * Formats the dependencies of a file.
    * @param fileDependencies - The dependencies of the file.
@@ -86,7 +108,7 @@ export class CDependencyFormatter {
       if (!symbols[id]) {
         symbols[id] = {
           id: id,
-          type: symbol.declaration.type as SymbolType,
+          type: this.#formatSymbolType(symbol.declaration.type),
           lineCount:
             symbol.declaration.node.endPosition.row -
             symbol.declaration.node.startPosition.row,

packages/cli/src/languagePlugins/c/dependencyFormatting/types.ts

@@ -1,4 +1,10 @@
-import { SymbolType } from "../headerResolver/types.js";
+import {
+  C_ENUM_TYPE,
+  C_UNION_TYPE,
+  C_STRUCT_TYPE,
+  C_TYPEDEF_TYPE,
+  C_VARIABLE_TYPE,
+} from "../headerResolver/types.js";
 import Parser from "tree-sitter";
 
 /**
@@ -18,12 +24,21 @@ export interface CDependent {
   symbols: Record<string, string>;
 }
 
+export const C_DEP_FUNCTION_TYPE = "function";
+export type CDepSymbolType =
+  | typeof C_ENUM_TYPE
+  | typeof C_UNION_TYPE
+  | typeof C_STRUCT_TYPE
+  | typeof C_TYPEDEF_TYPE
+  | typeof C_VARIABLE_TYPE
+  | typeof C_DEP_FUNCTION_TYPE;
+
 /**
  * Represents a symbol in a C file
  */
 export interface CDepSymbol {
   id: string;
-  type: SymbolType;
+  type: CDepSymbolType;
   lineCount: number;
   characterCount: number;
   node: Parser.SyntaxNode;

packages/cli/src/languagePlugins/c/headerResolver/index.test.ts

@@ -72,7 +72,7 @@ describe("CHeaderResolver", () => {
     expect(drink_t.filepath).toBe(burgers);
   });
 
-  test("resolves variables and constant macros", () => {
+  test("resolves variables", () => {
     const classicburger = exportedSymbols.find(
       (symbol) => symbol.name === "classicBurger",
     );
@@ -94,12 +94,14 @@ describe("CHeaderResolver", () => {
     expect(burger_count.node.type).toBe("declaration");
     expect(burger_count.identifierNode.type).toBe("identifier");
     expect(burger_count.filepath).toBe(burgers);
+  });
 
+  test("resolves macro constants", () => {
     const burgers_h = exportedSymbols.find(
       (symbol) => symbol.name === "BURGERS_H",
     );
     expect(burgers_h).toBeDefined();
-    expect(burgers_h.type).toBe("variable");
+    expect(burgers_h.type).toBe("macro_constant");
     expect(burgers_h.specifiers).toEqual([]);
     expect(burgers_h.qualifiers).toEqual([]);
     expect(burgers_h.node.type).toBe("preproc_def");
@@ -110,28 +112,30 @@ describe("CHeaderResolver", () => {
       (symbol) => symbol.name === "MAX_BURGERS",
     );
     expect(max_burgers).toBeDefined();
-    expect(max_burgers.type).toBe("variable");
+    expect(max_burgers.type).toBe("macro_constant");
     expect(max_burgers.specifiers).toEqual([]);
     expect(max_burgers.qualifiers).toEqual([]);
     expect(max_burgers.node.type).toBe("preproc_def");
     expect(max_burgers.identifierNode.type).toBe("identifier");
     expect(max_burgers.filepath).toBe(burgers);
   });
 
-  test("resolves functions and macros", () => {
+  test("resolves function signatures", () => {
     const function_names = exportedSymbols
-      .filter((symbol) => symbol.type === "function")
+      .filter((symbol) => symbol.type === "function_signature")
       .map((symbol) => symbol.name);
-    expect(function_names).toHaveLength(5);
+    expect(function_names).toHaveLength(4);
     expect(function_names).toContain("get_burger_by_id");
     expect(function_names).toContain("get_cheapest_burger");
     expect(function_names).toContain("create_burger");
     expect(function_names).toContain("destroy_burger");
-    expect(function_names).toContain("MAX");
+    expect(function_names).not.toContain("MAX");
+  });
 
+  test("resolves macro functions", () => {
     const max_macro = exportedSymbols.find((symbol) => symbol.name === "MAX");
     expect(max_macro).toBeDefined();
-    expect(max_macro.type).toBe("function");
+    expect(max_macro.type).toBe("macro_function");
     expect(max_macro.specifiers).toEqual([]);
     expect(max_macro.qualifiers).toEqual([]);
     expect(max_macro.node.type).toBe("preproc_function_def");
@@ -176,7 +180,7 @@ describe("CHeaderResolver", () => {
       (s) => s.name === "PlaceholderFunction",
     );
     expect(placeholderfunction).toBeDefined();
-    expect(placeholderfunction.type).toBe("function");
+    expect(placeholderfunction.type).toBe("function_signature");
     expect(placeholderfunction.specifiers).toEqual([]);
     expect(placeholderfunction.qualifiers).toEqual([]);
     expect(placeholderfunction.node.type).toBe("declaration");

packages/cli/src/languagePlugins/c/headerResolver/index.ts

@@ -24,7 +24,7 @@ export class CHeaderResolver {
     const query = C_DECLARATION_QUERY;
     const captures = query.captures(file.rootNode);
     for (const capture of captures) {
-      if (capture.name !== "decl") {
+      if (capture.name !== "decl" && capture.name !== "function_definition") {
         let idNode: Parser.SyntaxNode;
         if (capture.name !== "typedef") {
           idNode = capture.node.childForFieldName("name");
@@ -65,7 +65,11 @@ export class CHeaderResolver {
           }
         }
         const type =
-          currentNode.type === "function_declarator" ? "function" : "variable";
+          capture.name === "function_definition"
+            ? "function_definition"
+            : currentNode.type === "function_declarator"
+              ? "function_signature"
+              : "variable";
         const idNode = currentNode.childForFieldName("declarator");
         exportedSymbols.push({
           name: idNode.text,

packages/cli/src/languagePlugins/c/headerResolver/queries.ts

@@ -13,6 +13,7 @@ export const C_DECLARATION_QUERY = new Parser.Query(
     (struct_specifier) @struct
     (enum_specifier) @enum
     (union_specifier) @union
+    (function_definition) @function_definition
     (type_definition
     	type:[
         	(struct_specifier
@@ -41,6 +42,7 @@ export const C_DECLARATION_QUERY = new Parser.Query(
     (struct_specifier) @struct
     (enum_specifier) @enum
     (union_specifier) @union
+    (function_definition) @function_definition
     (type_definition
     	type:[
         	(struct_specifier
@@ -63,7 +65,7 @@ export const C_DECLARATION_QUERY = new Parser.Query(
         ]
     ) @typedef
   ])
-  (preproc_def) @variable
-  (preproc_function_def) @function
+  (preproc_def) @macro_constant
+  (preproc_function_def) @macro_function
   `,
 );

packages/cli/src/languagePlugins/c/headerResolver/types.ts

@@ -4,7 +4,10 @@ import Parser from "tree-sitter";
 export const C_STRUCT_TYPE = "struct";
 export const C_UNION_TYPE = "union";
 export const C_ENUM_TYPE = "enum";
-export const C_FUNCTION_TYPE = "function";
+export const C_FUNCTION_DEFINITION_TYPE = "function_definition";
+export const C_FUNCTION_SIGNATURE_TYPE = "function_signature";
+export const C_MACRO_FUNCTION_TYPE = "macro_function";
+export const C_MACRO_CONSTANT_TYPE = "macro_constant";
 export const C_VARIABLE_TYPE = "variable";
 export const C_TYPEDEF_TYPE = "typedef";
 
@@ -25,7 +28,10 @@ export type SymbolType =
   | typeof C_STRUCT_TYPE
   | typeof C_UNION_TYPE
   | typeof C_ENUM_TYPE
-  | typeof C_FUNCTION_TYPE
+  | typeof C_FUNCTION_DEFINITION_TYPE
+  | typeof C_FUNCTION_SIGNATURE_TYPE
+  | typeof C_MACRO_FUNCTION_TYPE
+  | typeof C_MACRO_CONSTANT_TYPE
   | typeof C_VARIABLE_TYPE
   | typeof C_TYPEDEF_TYPE;
 

packages/cli/src/languagePlugins/c/invocationResolver/index.test.ts

@@ -12,7 +12,7 @@ describe("CInvocationResolver", () => {
   const invocationResolver = new CInvocationResolver(includeResolver);
   const burgersh = path.join(cFilesFolder, "burgers.h");
   const burgersc = path.join(cFilesFolder, "burgers.c");
-  const personnelh = path.join(cFilesFolder, "personnel.h");
+  const personnelc = path.join(cFilesFolder, "personnel.c");
   const crashcasesh = path.join(cFilesFolder, "crashcases.h");
   const main = path.join(cFilesFolder, "main.c");
   const registry = symbolRegistry.getRegistry();
@@ -41,7 +41,7 @@ describe("CInvocationResolver", () => {
   });
 
   test("resolves invocations for burgers.c", () => {
-    const symbols = registry.get(burgersh).symbols;
+    const symbols = registry.get(burgersc).symbols;
     if (!symbols) {
       throw new Error(`Symbol not found for: ${burgersc}`);
     }
@@ -51,7 +51,8 @@ describe("CInvocationResolver", () => {
     const create_resolved = Array.from(
       create_burger_invocations.resolved.keys(),
     );
-    expect(create_resolved.length).toBe(4);
+    expect(create_resolved.length).toBe(5);
+    expect(create_resolved).toContain("create_burger");
     expect(create_resolved).toContain("Burger");
     expect(create_resolved).toContain("Condiment");
     expect(create_resolved).toContain("Sauce");
@@ -63,7 +64,8 @@ describe("CInvocationResolver", () => {
     const destroy_resolved = Array.from(
       destroy_burger_invocations.resolved.keys(),
     );
-    expect(destroy_resolved.length).toBe(1);
+    expect(destroy_resolved.length).toBe(2);
+    expect(destroy_resolved).toContain("destroy_burger");
     expect(destroy_resolved).toContain("Burger");
 
     const symbolsc = registry.get(burgersc).symbols;
@@ -78,17 +80,18 @@ describe("CInvocationResolver", () => {
   });
 
   test("resolves invocations for personnel.c", () => {
-    const symbols = registry.get(personnelh).symbols;
+    const symbols = registry.get(personnelc).symbols;
     if (!symbols) {
-      throw new Error(`Symbol not found for: ${personnelh}`);
+      throw new Error(`Symbol not found for: ${personnelc}`);
     }
     const create_employee = symbols.get("create_employee");
     const create_employee_invocations =
       invocationResolver.getInvocationsForSymbol(create_employee);
     const create_resolved = Array.from(
       create_employee_invocations.resolved.keys(),
     );
-    expect(create_resolved.length).toBe(5);
+    expect(create_resolved.length).toBe(6);
+    expect(create_resolved).toContain("create_employee");
     expect(create_resolved).toContain("Employee");
     expect(create_resolved).toContain("Department");
     expect(create_resolved).toContain("MAX_EMPLOYEES");

packages/cli/src/languagePlugins/c/invocationResolver/index.ts

@@ -1,7 +1,11 @@
 import { Invocations } from "./types.js";
 import { C_INVOCATION_QUERY, C_MACRO_CONTENT_QUERY } from "./queries.js";
 import { CIncludeResolver } from "../includeResolver/index.js";
-import { Symbol, Function } from "../symbolRegistry/types.js";
+import {
+  Symbol,
+  FunctionDefinition,
+  FunctionSignature,
+} from "../symbolRegistry/types.js";
 import Parser from "tree-sitter";
 import { cParser } from "../../../helpers/treeSitter/parsers.js";
 
@@ -66,14 +70,17 @@ export class CInvocationResolver {
   }
 
   getInvocationsForSymbol(symbol: Symbol) {
-    let filepath = symbol.declaration.filepath;
-    let node = symbol.declaration.node;
-    if (symbol instanceof Function) {
-      filepath = symbol.definitionPath;
-      node = symbol.definition;
-    }
+    const filepath = symbol.declaration.filepath;
+    const node = symbol.declaration.node;
     const name = symbol.name;
     const invocations = this.getInvocationsForNode(node, filepath, name);
+    const resolved = invocations.resolved;
+    if (symbol instanceof FunctionSignature && symbol.definition) {
+      resolved.set(symbol.name, symbol.definition);
+    }
+    if (symbol instanceof FunctionDefinition && symbol.signature) {
+      resolved.set(symbol.name, symbol.signature);
+    }
     return {
       resolved: invocations.resolved,
       unresolved: invocations.unresolved,