Invocation resolver

Author: LeBoufty

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

@@ -0,0 +1,70 @@
+import { Invocations } from "./types.js";
+import { C_INVOCATION_QUERY } from "./queries.js";
+import { CIncludeResolver } from "../includeResolver/index.js";
+import { Symbol, Function } from "../symbolRegistry/types.js";
+import Parser from "tree-sitter";
+
+export class CInvocationResolver {
+  includeResolver: CIncludeResolver;
+
+  constructor(includeResolver: CIncludeResolver) {
+    this.includeResolver = includeResolver;
+  }
+
+  getInvocationsForNode(
+    node: Parser.SyntaxNode,
+    filepath: string,
+    symbolname: string = undefined,
+  ): Invocations {
+    const availableSymbols = this.includeResolver
+      .getInclusions()
+      .get(filepath).symbols;
+    const localSymbols =
+      this.includeResolver.symbolRegistry.get(filepath).symbols;
+    const unresolved = new Set<string>();
+    const resolved = new Map<string, Symbol>();
+    const captures = C_INVOCATION_QUERY.captures(node);
+    for (const capture of captures) {
+      const name = capture.node.text;
+      // if the symbol name is the same as the one we are looking at, skip it
+      if (symbolname && name === symbolname) {
+        continue;
+      }
+      if (availableSymbols.has(name)) {
+        resolved.set(name, availableSymbols.get(name));
+      } else if (localSymbols.has(name)) {
+        resolved.set(name, localSymbols.get(name));
+      } else {
+        unresolved.add(name);
+      }
+    }
+    return {
+      resolved,
+      unresolved,
+    };
+  }
+
+  getInvocationsForFile(filepath: string): Invocations {
+    const symbols = this.includeResolver.symbolRegistry.get(filepath).symbols;
+    let unresolved = new Set<string>();
+    const resolved = new Map<string, Symbol>();
+    for (const symbol of symbols.values()) {
+      const node =
+        symbol instanceof Function
+          ? (symbol as Function).definition
+          : symbol.declaration.node;
+      const name = symbol.name;
+      const invocations = this.getInvocationsForNode(node, filepath, name);
+      unresolved = new Set([...unresolved, ...invocations.unresolved]);
+      for (const [key, value] of invocations.resolved) {
+        if (!resolved.has(key)) {
+          resolved.set(key, value);
+        }
+      }
+    }
+    return {
+      resolved,
+      unresolved,
+    };
+  }
+}

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

@@ -0,0 +1,10 @@
+import Parser from "tree-sitter";
+import { cParser } from "../../../helpers/treeSitter/parsers.js";
+
+export const C_INVOCATION_QUERY = new Parser.Query(
+  cParser.getLanguage(),
+  `
+  (type_identifier) @type
+  (identifier) @id
+  `, // The nuclear option, but unlike C# we can afford to do it.
+);

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

@@ -0,0 +1,9 @@
+import { Symbol } from "../symbolRegistry/types.js";
+
+/** Interface representing the invoked symbols in a file */
+export interface Invocations {
+  /** Symbols that are part of the project */
+  resolved: Map<string, Symbol>;
+  /** Symbols that are not part of the project or local variables */
+  unresolved: Set<string>;
+}