Add Callgraph

cspell.json

@@ -101,7 +101,8 @@
     "Dont",
     "consteval",
     "Georgiy",
-    "Komarov"
+    "Komarov",
+    "callgraph"
   ],
   "flagWords": [],
   "ignorePaths": [

src/detectors/detector.ts

@@ -355,7 +355,7 @@ export const BuiltInDetectors: Record<string, DetectorEntry> = {
       import("./builtin/sendInLoop").then(
         (module) => new module.SendInLoop(ctx),
       ),
-    enabledByDefault: false,
+    enabledByDefault: true,
   },
   CellOverflow: {
     loader: (ctx: MistiContext) =>

src/internals/ir/builders/astStore.ts

@@ -225,3 +225,4 @@ export class TactASTStoreBuilder {
     }
   }
 }
+export { TactASTStore };

src/internals/ir/builders/ir.ts

@@ -13,13 +13,15 @@ import {
   FunctionName,
   ProjectName,
 } from "..";
-import { TactASTStoreBuilder } from "./astStore";
 import { ImportGraphBuilder } from "./imports";
 import { MistiContext } from "../../context";
 import { InternalException } from "../../exceptions";
 import { formatPosition } from "../../tact";
 import { TactConfigManager } from "../../tact/config";
 import { unreachable } from "../../util";
+import { CallGraph } from "../callGraph";
+import { TactASTStoreBuilder } from "./astStore";
+import { TactASTStore } from "./astStore";
 import {
   AstContractDeclaration,
   AstExpression,
@@ -54,6 +56,17 @@ function generateReceiveName(receive: AstReceiver): string {
   }
 }
 
+export class TactCallGraphBuilder {
+  /**
+   * Builds a CallGraph for the provided AST Store.
+   * @param astStore The TactASTStore containing AST nodes and function definitions.
+   * @returns A CallGraph instance built from the AST nodes.
+   */
+  static buildCallGraph(astStore: TactASTStore): CallGraph {
+    const callGraph = new CallGraph();
+    return callGraph.build(astStore);
+  }
+}
 /**
  * Represents a stateful object which is responsible for constructing the IR of a Tact project.
  *
@@ -97,12 +110,15 @@ export class TactIRBuilder {
   build(): CompilationUnit {
     const functions = this.createFunctions();
     const contracts = this.createContracts();
+    const tactASTStore = TactASTStoreBuilder.make(this.ctx, this.ast).build();
+    const callGraph = TactCallGraphBuilder.buildCallGraph(tactASTStore);
     return new CompilationUnit(
       this.projectName,
-      TactASTStoreBuilder.make(this.ctx, this.ast).build(),
+      tactASTStore,
       ImportGraphBuilder.make(this.ctx).build(),
       functions,
       contracts,
+      callGraph,
     );
   }
 

src/internals/ir/callGraph.ts

@@ -0,0 +1,237 @@
+import { unreachable } from "../util";
+import { TactASTStore } from "./astStore";
+import { IdxGenerator } from "./indices";
+import {
+  AstFunctionDef,
+  AstReceiver,
+  AstContractInit,
+  AstStatement,
+  AstStaticCall,
+  AstMethodCall,
+  AstExpression,
+  AstStructFieldInitializer,
+} from "@tact-lang/compiler/dist/grammar/ast";
+
+type NodeId = number;
+type EdgeId = number;
+
+export class CGEdge {
+  public idx: EdgeId;
+  constructor(
+    public src: NodeId,
+    public dst: NodeId,
+  ) {
+    this.idx = IdxGenerator.next("cg_edge");
+  }
+}
+
+export class CGNode {
+  public idx: NodeId;
+  public inEdges: Set<EdgeId> = new Set();
+  public outEdges: Set<EdgeId> = new Set();
+  constructor(
+    public astId: number,
+    public name: string,
+  ) {
+    this.idx = IdxGenerator.next("cg_node");
+  }
+}
+
+export class CallGraph {
+  private nodeMap: Map<NodeId, CGNode> = new Map();
+  private edgesMap: Map<EdgeId, CGEdge> = new Map();
+
+  public getNodes(): Map<NodeId, CGNode> {
+    return this.nodeMap;
+  }
+
+  public getEdges(): Map<EdgeId, CGEdge> {
+    return this.edgesMap;
+  }
+
+  build(astStore: TactASTStore): CallGraph {
+    this.addFunctionsToNodes(astStore);
+    this.analyzeFunctionCalls(astStore);
+    return this;
+  }
+
+  private addFunctionsToNodes(astStore: TactASTStore) {
+    for (const func of astStore.getFunctions()) {
+      const funcName = this.getFunctionName(func);
+      if (funcName) {
+        const node = new CGNode(func.id, funcName);
+        this.nodeMap.set(func.id, node);
+      }
+    }
+  }
+
+  private analyzeFunctionCalls(astStore: TactASTStore) {
+    for (const func of astStore.getFunctions()) {
+      const funcName = this.getFunctionName(func);
+      if (funcName) {
+        this.processStatements(func.statements, func.id);
+      }
+    }
+  }
+
+  /**
+   * Get function name based on its kind.
+   * @param func - The function definition or initializer.
+   * @returns The name of the function.
+   */
+  private getFunctionName(
+    func: AstFunctionDef | AstReceiver | AstContractInit,
+  ): string {
+    switch (func.kind) {
+      case "function_def":
+        return func.name.text;
+      case "contract_init":
+        return `contract_init_${func.id}`;
+      case "receiver":
+        return `receiver_${func.id}`;
+      default:
+        unreachable(func);
+    }
+  }
+
+  /**
+   * Process the statements of a function.
+   * @param statements - The AST statements.
+   * @param callerId - The ID of the calling function.
+   *
+   * Note: We don't use `foldStatements` or `forEachStatement` here because
+   * the logic is specific to call graph construction, and we want to
+   * maintain control over the traversal and processing.
+   */
+  private processStatements(statements: AstStatement[], callerId: number) {
+    for (const stmt of statements) {
+      switch (stmt.kind) {
+        case "statement_expression":
+          this.processExpression(stmt.expression, callerId);
+          break;
+        case "statement_condition":
+          this.processStatements(stmt.trueStatements, callerId);
+          if (stmt.falseStatements) {
+            this.processStatements(stmt.falseStatements, callerId);
+          }
+          break;
+        case "statement_while":
+        case "statement_until":
+        case "statement_repeat":
+        case "statement_foreach":
+          this.processStatements(stmt.statements, callerId);
+          break;
+        case "statement_try":
+          this.processStatements(stmt.statements, callerId);
+          break;
+        case "statement_try_catch":
+          this.processStatements(stmt.statements, callerId);
+          this.processStatements(stmt.catchStatements, callerId);
+          break;
+        case "statement_let":
+        case "statement_return":
+        case "statement_assign":
+        case "statement_augmentedassign":
+          if (stmt.expression) {
+            this.processExpression(stmt.expression, callerId);
+          }
+          break;
+        default:
+          console.warn(`Unhandled statement type: ${(stmt as any).kind}`, stmt);
+      }
+    }
+  }
+
+  private processExpression(
+    expr: AstExpression | AstStructFieldInitializer,
+    callerId: NodeId,
+  ) {
+    this.forEachExpression(expr, (nestedExpr) => {
+      let calleeId: NodeId | undefined;
+      if (nestedExpr.kind === "static_call") {
+        const staticCall = nestedExpr as AstStaticCall;
+        calleeId = this.findOrAddFunction(staticCall.function.text);
+      } else if (nestedExpr.kind === "method_call") {
+        const methodCall = nestedExpr as AstMethodCall;
+        calleeId = this.findOrAddFunction(methodCall.method.text);
+      }
+      if (calleeId !== undefined) {
+        this.addEdge(callerId, calleeId);
+      }
+    });
+  }
+
+  private forEachExpression(
+    expr: AstExpression | AstStructFieldInitializer,
+    callback: (expr: AstExpression) => void,
+  ) {
+    if (expr.kind !== "struct_field_initializer") {
+      callback(expr as AstExpression);
+    }
+
+    switch (expr.kind) {
+      case "static_call":
+      case "method_call": {
+        const callExpr = expr as AstStaticCall | AstMethodCall;
+        for (const arg of callExpr.args) {
+          this.forEachExpression(arg, callback);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  private findOrAddFunction(name: string): NodeId {
+    const existingNode = Array.from(this.nodeMap.values()).find(
+      (node: CGNode) => node.name === name,
+    );
+    if (existingNode) {
+      return existingNode.astId;
+    }
+    const newNode = new CGNode(IdxGenerator.next("cg_node"), name);
+    this.nodeMap.set(newNode.astId, newNode);
+    return newNode.astId;
+  }
+
+  private addEdge(src: NodeId, dst: NodeId) {
+    const srcNode = this.nodeMap.get(src);
+    const dstNode = this.nodeMap.get(dst);
+    if (srcNode && dstNode) {
+      const edge = new CGEdge(src, dst);
+      this.edgesMap.set(edge.idx, edge);
+      srcNode.outEdges.add(edge.idx);
+      dstNode.inEdges.add(edge.idx);
+    }
+  }
+
+  areConnected(src: NodeId, dst: NodeId): boolean {
+    const srcNode = this.nodeMap.get(src);
+    const dstNode = this.nodeMap.get(dst);
+    if (!srcNode || !dstNode) {
+      return false;
+    }
+    const queue: NodeId[] = [src];
+    const visited = new Set<NodeId>([src]);
+
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+
+      if (current === dst) {
+        return true;
+      }
+      const currentNode = this.nodeMap.get(current);
+      if (currentNode) {
+        for (const edgeId of currentNode.outEdges) {
+          const edge = this.edgesMap.get(edgeId);
+          if (edge && !visited.has(edge.dst)) {
+            visited.add(edge.dst);
+            queue.push(edge.dst);
+          }
+        }
+      }
+    }
+    return false;
+  }
+}

src/internals/ir/index.ts

@@ -9,6 +9,7 @@ export {
   EntryOrigin,
 } from "./cfg";
 export { TactASTStore } from "./astStore";
+export { CGEdge, CGNode } from "./callGraph";
 export * from "./imports";
 export { CompilationUnit, Contract } from "./ir";
 export * from "./types";

src/internals/ir/ir.ts

@@ -4,6 +4,7 @@
  * @packageDocumentation
  */
 import { TactASTStore } from "./astStore";
+import { CallGraph } from "./callGraph";
 import { BasicBlock, CFG } from "./cfg";
 import { ImportGraph } from "./imports";
 import { IdxGenerator } from "./indices";
@@ -36,6 +37,7 @@ export class CompilationUnit {
     public imports: ImportGraph,
     public functions: Map<CFGIdx, CFG>,
     public contracts: Map<ContractIdx, Contract>,
+    public callGraph: CallGraph,
   ) {}
 
   /**