@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/call-graph.d.ts

@@ -0,0 +1,35 @@
+import { ProgramIR } from "../api/index.js";
+/**
+ * Represents a node in the call graph
+ */
+interface CallGraphNode {
+    /** Symbol name */
+    name: string;
+    /** Type of symbol */
+    kind: "function" | "class" | "enum" | "variable" | "type_alias";
+    /** Names of symbols this node references */
+    dependencies: Set<string>;
+    /** Source for debugging/diagnostics */
+    source?: {
+        line: number;
+        column: number;
+    };
+}
+/**
+ * Call graph representing dependencies between symbols
+ */
+export interface CallGraph {
+    /** All nodes in the graph, keyed by symbol name */
+    nodes: Map<string, CallGraphNode>;
+    /** Reverse mapping: symbol -> symbols that reference it */
+    referencedBy: Map<string, Set<string>>;
+}
+/**
+ * Build a call graph from program IR
+ */
+export declare function buildCallGraph(program: ProgramIR): CallGraph;
+/**
+ * Get all symbols reachable from a starting set
+ */
+export declare function getReachableSymbols(graph: CallGraph, entryPoints: Set<string>): Set<string>;
+export {};

package/dist/ir/call-graph.js

@@ -0,0 +1,194 @@
+import { collectExpressionIdentifiers, collectStatementIdentifiers } from "./identifier-collector.js";
+import { parsedCollectNamedTypes } from "../api/shared/cpp-type-ir.js";
+/**
+ * Build a call graph from program IR
+ */
+export function buildCallGraph(program) {
+    const nodes = new Map();
+    const referencedBy = new Map();
+    // Helper to add a reference
+    const addReference = (from, to) => {
+        if (!referencedBy.has(to)) {
+            referencedBy.set(to, new Set());
+        }
+        referencedBy.get(to).add(from);
+    };
+    // Process functions
+    for (const fn of program.functions) {
+        const dependencies = new Set();
+        // Add parameters as local (don't count as external dependencies)
+        const localBindings = new Set(fn.parameters.map((p) => p.name));
+        // Collect type references from parameter types (e.g. SampleWindow)
+        for (const param of fn.parameters) {
+            for (const match of parsedCollectNamedTypes(param.cppType)) {
+                dependencies.add(match);
+            }
+        }
+        // Collect identifiers from function body
+        for (const statement of fn.statements) {
+            for (const id of collectStatementIdentifiers(statement)) {
+                if (!localBindings.has(id)) {
+                    dependencies.add(id);
+                }
+            }
+        }
+        nodes.set(fn.originalName, {
+            name: fn.originalName,
+            kind: "function",
+            dependencies,
+            source: {
+                line: fn.sourceSpan.startLine,
+                column: fn.sourceSpan.startColumn,
+            },
+        });
+        // Update reverse mapping
+        for (const dep of dependencies) {
+            addReference(fn.originalName, dep);
+        }
+    }
+    // Process classes
+    for (const cls of program.classes) {
+        const dependencies = new Set();
+        // Collect from fields
+        for (const field of cls.fields) {
+            if (field.initializer) {
+                for (const id of collectExpressionIdentifiers(field.initializer)) {
+                    dependencies.add(id);
+                }
+            }
+            // Field type might reference other classes
+            for (const match of parsedCollectNamedTypes(field.cppType)) {
+                if (match !== cls.name)
+                    dependencies.add(match);
+            }
+        }
+        // Collect from constructor
+        if (cls.constructor) {
+            const localBindings = new Set(cls.constructor.parameters.map((p) => p.name));
+            for (const statement of cls.constructor.statements) {
+                for (const id of collectStatementIdentifiers(statement)) {
+                    if (!localBindings.has(id)) {
+                        dependencies.add(id);
+                    }
+                }
+            }
+        }
+        // Collect from methods
+        for (const method of cls.methods) {
+            const localBindings = new Set(method.parameters.map((p) => p.name));
+            for (const statement of method.statements) {
+                for (const id of collectStatementIdentifiers(statement)) {
+                    if (!localBindings.has(id)) {
+                        dependencies.add(id);
+                    }
+                }
+            }
+        }
+        nodes.set(cls.name, {
+            name: cls.name,
+            kind: "class",
+            dependencies,
+            source: {
+                line: cls.sourceSpan.startLine,
+                column: cls.sourceSpan.startColumn,
+            },
+        });
+        // Update reverse mapping
+        for (const dep of dependencies) {
+            addReference(cls.name, dep);
+        }
+    }
+    // Process enums
+    for (const enumDef of program.enums) {
+        // Enums might reference other enums for values, but typically are leaf nodes
+        nodes.set(enumDef.name, {
+            name: enumDef.name,
+            kind: "enum",
+            dependencies: new Set(),
+            source: {
+                line: enumDef.sourceSpan.startLine,
+                column: enumDef.sourceSpan.startColumn,
+            },
+        });
+    }
+    // Process type aliases
+    for (const typeAlias of program.typeAliases) {
+        const dependencies = new Set();
+        for (const match of parsedCollectNamedTypes(typeAlias.cppType)) {
+            dependencies.add(match);
+        }
+        nodes.set(typeAlias.name, {
+            name: typeAlias.name,
+            kind: "type_alias",
+            dependencies,
+            source: {
+                line: typeAlias.sourceSpan.startLine,
+                column: typeAlias.sourceSpan.startColumn,
+            },
+        });
+        for (const dep of dependencies) {
+            addReference(typeAlias.name, dep);
+        }
+    }
+    // Process top-level statements.
+    // Named var_decl statements get their own nodes so they can be
+    // individually tree-shaken.  All other (non-var_decl) statements
+    // contribute to the special __top_level__ node.
+    const topLevelDependencies = new Set();
+    for (const statement of program.topLevelStatements) {
+        if (statement.kind === "var_decl") {
+            const varDeps = new Set();
+            if (statement.initializer) {
+                for (const id of collectExpressionIdentifiers(statement.initializer)) {
+                    varDeps.add(id);
+                    topLevelDependencies.add(id);
+                }
+            }
+            nodes.set(statement.name, {
+                name: statement.name,
+                kind: "variable",
+                dependencies: varDeps,
+            });
+            for (const dep of varDeps) {
+                addReference(statement.name, dep);
+            }
+        }
+        else {
+            for (const id of collectStatementIdentifiers(statement)) {
+                topLevelDependencies.add(id);
+            }
+        }
+    }
+    nodes.set("__top_level__", {
+        name: "__top_level__",
+        kind: "variable",
+        dependencies: topLevelDependencies,
+    });
+    for (const dep of topLevelDependencies) {
+        addReference("__top_level__", dep);
+    }
+    return { nodes, referencedBy };
+}
+/**
+ * Get all symbols reachable from a starting set
+ */
+export function getReachableSymbols(graph, entryPoints) {
+    const reachable = new Set();
+    const worklist = [...entryPoints];
+    while (worklist.length > 0) {
+        const current = worklist.pop();
+        if (reachable.has(current)) {
+            continue;
+        }
+        reachable.add(current);
+        const node = graph.nodes.get(current);
+        if (node) {
+            for (const dep of node.dependencies) {
+                if (!reachable.has(dep)) {
+                    worklist.push(dep);
+                }
+            }
+        }
+    }
+    return reachable;
+}

package/dist/ir/compile-time-only.d.ts

@@ -0,0 +1,2 @@
+export declare function isCompileTimeOnlyCallName(name: string): boolean;
+export declare function isCompileTimeOnlyClassName(name: string): boolean;

package/dist/ir/compile-time-only.js

@@ -0,0 +1,16 @@
+const COMPILE_TIME_ONLY_CALLS = new Set([
+    "registerPlatformStrategy",
+    "registerPolyfill",
+    "registerBoard",
+    "defineBoardManifest",
+]);
+const COMPILE_TIME_ONLY_CLASSES = new Set([
+    "NativeStrategy",
+    "BoardStrategy",
+]);
+export function isCompileTimeOnlyCallName(name) {
+    return COMPILE_TIME_ONLY_CALLS.has(name);
+}
+export function isCompileTimeOnlyClassName(name) {
+    return COMPILE_TIME_ONLY_CLASSES.has(name) || name.endsWith("Strategy");
+}

package/dist/ir/declaration-builders.d.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+import { Diagnostic } from "../types.js";
+import { ClassIR, EnumIR, InterfaceIR, RegisterClassIR, TypeAliasIR } from "../api/index.js";
+import { CppTypeHint } from "./type-resolution.js";
+import { PointerTracker } from "./build-ir-state.js";
+export declare function classDeclarationToIR(node: ts.ClassDeclaration, fileName: string, sourceText: string, diagnostics: Diagnostic[], functionReturnTypes: Map<string, CppTypeHint>, typeAliasNodes: Map<string, ts.TypeNode>, registerClasses: RegisterClassIR[], pointerVars?: PointerTracker, scopePrefix?: string): ClassIR | undefined;
+export declare function enumDeclarationToIR(node: ts.EnumDeclaration, fileName: string, sourceText: string): EnumIR | undefined;
+export declare function interfaceDeclarationToIR(node: ts.InterfaceDeclaration, fileName: string, sourceText: string, typeAliasNodes: Map<string, ts.TypeNode>): InterfaceIR | undefined;
+export declare function typeAliasDeclarationToIR(node: ts.TypeAliasDeclaration, fileName: string, sourceText: string, typeAliasNodes: Map<string, ts.TypeNode>): TypeAliasIR | undefined;