c-next 0.1.70 → 0.1.72

package/src/transpiler/state/__tests__/SymbolRegistry.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Unit tests for SymbolRegistry
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import SymbolRegistry from "../SymbolRegistry";
+import FunctionUtils from "../../../utils/FunctionUtils";
+import TTypeUtils from "../../../utils/TTypeUtils";
+
+describe("SymbolRegistry", () => {
+  beforeEach(() => {
+    SymbolRegistry.reset();
+  });
+
+  describe("getGlobalScope", () => {
+    it("returns the global scope singleton", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      expect(global.kind).toBe("scope");
+      expect(global.name).toBe("");
+      expect(global.parent).toBe(global);
+    });
+
+    it("returns same instance on multiple calls", () => {
+      const g1 = SymbolRegistry.getGlobalScope();
+      const g2 = SymbolRegistry.getGlobalScope();
+      expect(g1).toBe(g2);
+    });
+  });
+
+  describe("getOrCreateScope", () => {
+    it("returns global scope for empty path", () => {
+      const scope = SymbolRegistry.getOrCreateScope("");
+      expect(scope).toBe(SymbolRegistry.getGlobalScope());
+    });
+
+    it("creates scope with global parent for simple name", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      expect(scope.name).toBe("Test");
+      expect(scope.parent).toBe(SymbolRegistry.getGlobalScope());
+    });
+
+    it("returns same scope for same path", () => {
+      const s1 = SymbolRegistry.getOrCreateScope("Test");
+      const s2 = SymbolRegistry.getOrCreateScope("Test");
+      expect(s1).toBe(s2);
+    });
+
+    it("creates nested scopes for dotted path", () => {
+      const inner = SymbolRegistry.getOrCreateScope("Outer.Inner");
+      expect(inner.name).toBe("Inner");
+      expect(inner.parent.name).toBe("Outer");
+      expect(inner.parent.parent).toBe(SymbolRegistry.getGlobalScope());
+    });
+  });
+
+  describe("registerFunction", () => {
+    it("adds function to its scope", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const func = FunctionUtils.create({
+        name: "fillData",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      expect(scope.functions).toContain(func);
+    });
+  });
+
+  describe("resolveFunction", () => {
+    it("finds function in current scope", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const func = FunctionUtils.create({
+        name: "fillData",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const found = SymbolRegistry.resolveFunction("fillData", scope);
+      expect(found).toBe(func);
+    });
+
+    it("finds function in parent scope", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      const func = FunctionUtils.create({
+        name: "helper",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const childScope = SymbolRegistry.getOrCreateScope("Test");
+      const found = SymbolRegistry.resolveFunction("helper", childScope);
+      expect(found).toBe(func);
+    });
+
+    it("returns null for unknown function", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const found = SymbolRegistry.resolveFunction("unknown", scope);
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("reset", () => {
+    it("clears all registered symbols", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const func = FunctionUtils.create({
+        name: "foo",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      SymbolRegistry.reset();
+
+      const newGlobal = SymbolRegistry.getGlobalScope();
+      expect(newGlobal.functions).toHaveLength(0);
+
+      const found = SymbolRegistry.resolveFunction("foo", newGlobal);
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("findByMangledName", () => {
+    it("finds global function by bare name", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      const func = FunctionUtils.create({
+        name: "main",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("i32"),
+        visibility: "public",
+        body: null,
+        sourceFile: "main.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const found = SymbolRegistry.findByMangledName("main");
+      expect(found).toBe(func);
+    });
+
+    it("finds scoped function by mangled name", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Test");
+      const func = FunctionUtils.create({
+        name: "fillData",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const found = SymbolRegistry.findByMangledName("Test_fillData");
+      expect(found).toBe(func);
+    });
+
+    it("finds nested scope function by mangled name", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Outer.Inner");
+      const func = FunctionUtils.create({
+        name: "deepFunc",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 20,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const found = SymbolRegistry.findByMangledName("Outer_Inner_deepFunc");
+      expect(found).toBe(func);
+    });
+
+    it("returns null for unknown function", () => {
+      const found = SymbolRegistry.findByMangledName("Unknown_func");
+      expect(found).toBeNull();
+    });
+  });
+
+  describe("getScopeByMangledFunctionName", () => {
+    it("returns scope for scoped function", () => {
+      const scope = SymbolRegistry.getOrCreateScope("Motor");
+      const func = FunctionUtils.create({
+        name: "init",
+        scope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "motor.cnx",
+        sourceLine: 5,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const foundScope =
+        SymbolRegistry.getScopeByMangledFunctionName("Motor_init");
+      expect(foundScope).toBe(scope);
+    });
+
+    it("returns global scope for global function", () => {
+      const global = SymbolRegistry.getGlobalScope();
+      const func = FunctionUtils.create({
+        name: "helper",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "helpers.cnx",
+        sourceLine: 1,
+      });
+      SymbolRegistry.registerFunction(func);
+
+      const foundScope = SymbolRegistry.getScopeByMangledFunctionName("helper");
+      expect(foundScope).toBe(global);
+    });
+
+    it("returns null for unknown function", () => {
+      const foundScope =
+        SymbolRegistry.getScopeByMangledFunctionName("Unknown_func");
+      expect(foundScope).toBeNull();
+    });
+  });
+});

package/src/transpiler/{types → state}/__tests__/TranspilerState.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, it, expect, beforeEach } from "vitest";
 import TranspilerState from "../TranspilerState";
-import ICodeGenSymbols from "../ICodeGenSymbols";
+import ICodeGenSymbols from "../../types/ICodeGenSymbols";
 
 /** Create a minimal ICodeGenSymbols for testing */
 function createMockSymbolInfo(enumName?: string): ICodeGenSymbols {

package/src/transpiler/types/ICachedFileEntry.ts

@@ -2,7 +2,7 @@
  * Cached entry for a single header file
  */
 
-import IStructFieldInfo from "../logic/symbols/types/IStructFieldInfo";
+import IStructFieldInfo from "./symbols/IStructFieldInfo";
 import ISerializedSymbol from "./ISerializedSymbol";
 
 interface ICachedFileEntry {

package/src/transpiler/types/IConflict.ts

@@ -0,0 +1,14 @@
+/**
+ * Symbol conflict information for cross-language symbol detection.
+ */
+
+import TAnySymbol from "./symbols/TAnySymbol";
+
+interface IConflict {
+  symbolName: string;
+  definitions: TAnySymbol[];
+  severity: "error" | "warning";
+  message: string;
+}
+
+export default IConflict;

package/src/transpiler/types/IPipelineInput.ts

@@ -15,9 +15,6 @@ interface IPipelineInput {
 
   /** Whether to write generated output to disk */
   readonly writeOutputToDisk: boolean;
-
-  /** Skip Stage 4 (symbol conflict check) — standalone mode doesn't need it */
-  readonly skipConflictCheck?: boolean;
 }
 
 export default IPipelineInput;

package/src/transpiler/types/ISerializedSymbol.ts

@@ -1,6 +1,7 @@
 /**
  * Serialized symbol for JSON storage
  * Uses string values for enums to ensure clean JSON serialization
+ * ADR-055 Phase 7: Canonical format for cache storage (no ISymbol intermediate)
  */
 interface ISerializedSymbol {
   /** Symbol name */
@@ -27,6 +28,16 @@ interface ISerializedSymbol {
   accessModifier?: string;
   /** For arrays: element count. For integers: bit width */
   size?: number;
+  /** Whether this variable is an array */
+  isArray?: boolean;
+  /** Array dimensions for extern declarations */
+  arrayDimensions?: string[];
+  /** Whether this variable is const */
+  isConst?: boolean;
+  /** Whether this variable is atomic (volatile in C) */
+  isAtomic?: boolean;
+  /** Initial value for const variables */
+  initialValue?: string;
   /** Function parameters for header generation */
   parameters?: Array<{
     name: string;

package/src/transpiler/types/TPrimitiveKind.ts

@@ -0,0 +1,20 @@
+/**
+ * C-Next primitive type kinds.
+ *
+ * These are the built-in types that map directly to C types.
+ */
+type TPrimitiveKind =
+  | "void"
+  | "bool"
+  | "u8"
+  | "i8"
+  | "u16"
+  | "i16"
+  | "u32"
+  | "i32"
+  | "u64"
+  | "i64"
+  | "f32"
+  | "f64";
+
+export default TPrimitiveKind;

package/src/transpiler/types/TType.ts

@@ -0,0 +1,103 @@
+/**
+ * C-Next Type System - Discriminated Union
+ *
+ * TType represents all possible types in the C-Next type system.
+ * Each variant has a `kind` discriminator for type narrowing.
+ *
+ * Use TTypeUtils for factory functions and type guards.
+ */
+import TPrimitiveKind from "./TPrimitiveKind";
+
+/**
+ * Primitive type (built-in types that map to C types)
+ */
+interface TPrimitiveType {
+  readonly kind: "primitive";
+  readonly primitive: TPrimitiveKind;
+}
+
+/**
+ * Struct type reference
+ */
+interface TStructType {
+  readonly kind: "struct";
+  readonly name: string;
+}
+
+/**
+ * Enum type reference
+ */
+interface TEnumType {
+  readonly kind: "enum";
+  readonly name: string;
+}
+
+/**
+ * Bitmap type reference
+ * Bitmaps have a fixed bit width (8, 16, 24, 32)
+ */
+interface TBitmapType {
+  readonly kind: "bitmap";
+  readonly name: string;
+  readonly bitWidth: number;
+}
+
+/**
+ * Array type with element type and dimensions
+ * Dimensions can be numbers or strings (for C macro pass-through)
+ */
+interface TArrayType {
+  readonly kind: "array";
+  readonly elementType: TType;
+  readonly dimensions: ReadonlyArray<number | string>;
+}
+
+/**
+ * String type with capacity
+ * C-Next strings are fixed-capacity char arrays
+ */
+interface TStringType {
+  readonly kind: "string";
+  readonly capacity: number;
+}
+
+/**
+ * Callback type reference (function pointer type)
+ */
+interface TCallbackType {
+  readonly kind: "callback";
+  readonly name: string;
+}
+
+/**
+ * Hardware register type
+ */
+interface TRegisterType {
+  readonly kind: "register";
+  readonly name: string;
+}
+
+/**
+ * External type (C++ templates, external classes)
+ * Passes through unchanged to generated code
+ */
+interface TExternalType {
+  readonly kind: "external";
+  readonly name: string;
+}
+
+/**
+ * Discriminated union of all C-Next types
+ */
+type TType =
+  | TPrimitiveType
+  | TStructType
+  | TEnumType
+  | TBitmapType
+  | TArrayType
+  | TStringType
+  | TCallbackType
+  | TRegisterType
+  | TExternalType;
+
+export default TType;

package/src/transpiler/types/TVisibility.ts

@@ -0,0 +1,6 @@
+/**
+ * Visibility of a function or member within its scope
+ */
+type TVisibility = "public" | "private";
+
+export default TVisibility;

package/src/transpiler/types/symbol-kinds/TSymbolKind.ts

@@ -0,0 +1,10 @@
+import TSymbolKindCNext from "./TSymbolKindCNext";
+import TSymbolKindC from "./TSymbolKindC";
+import TSymbolKindCpp from "./TSymbolKindCpp";
+
+/**
+ * Union of all symbol kinds across supported languages.
+ */
+type TSymbolKind = TSymbolKindCNext | TSymbolKindC | TSymbolKindCpp;
+
+export default TSymbolKind;

package/src/transpiler/types/symbol-kinds/TSymbolKindC.ts

@@ -0,0 +1,12 @@
+/**
+ * Symbol kinds for C language constructs.
+ */
+type TSymbolKindC =
+  | "function"
+  | "variable"
+  | "struct"
+  | "enum"
+  | "enum_member"
+  | "type";
+
+export default TSymbolKindC;

package/src/transpiler/types/symbol-kinds/TSymbolKindCNext.ts

@@ -0,0 +1,16 @@
+/**
+ * Symbol kinds for C-Next language constructs.
+ */
+type TSymbolKindCNext =
+  | "function"
+  | "variable"
+  | "struct"
+  | "enum"
+  | "enum_member"
+  | "bitmap"
+  | "bitmap_field"
+  | "register"
+  | "register_member"
+  | "scope";
+
+export default TSymbolKindCNext;

package/src/transpiler/types/symbol-kinds/TSymbolKindCpp.ts

@@ -0,0 +1,14 @@
+/**
+ * Symbol kinds for C++ language constructs.
+ */
+type TSymbolKindCpp =
+  | "function"
+  | "variable"
+  | "struct"
+  | "enum"
+  | "enum_member"
+  | "class"
+  | "namespace"
+  | "type";
+
+export default TSymbolKindCpp;

package/src/transpiler/types/symbols/IBaseSymbol.ts

@@ -0,0 +1,31 @@
+import type TSymbolKindCNext from "../symbol-kinds/TSymbolKindCNext";
+import type ESourceLanguage from "../../../utils/types/ESourceLanguage";
+
+/**
+ * Base interface for all symbol types.
+ * All concrete symbol interfaces extend this with a narrowed `kind` literal.
+ */
+interface IBaseSymbol {
+  /** Symbol kind - discriminator for type narrowing */
+  readonly kind: TSymbolKindCNext;
+
+  /** Symbol name */
+  readonly name: string;
+
+  /** Scope this symbol belongs to (circular reference resolved at runtime) */
+  readonly scope: IBaseSymbol;
+
+  /** Source file where the symbol is defined */
+  readonly sourceFile: string;
+
+  /** Line number in the source file */
+  readonly sourceLine: number;
+
+  /** Source language (CNext, C, Cpp) */
+  readonly sourceLanguage: ESourceLanguage;
+
+  /** Whether this symbol is exported/public */
+  readonly isExported: boolean;
+}
+
+export default IBaseSymbol;

package/src/transpiler/{logic/symbols/types → types/symbols}/IBitmapFieldInfo.ts

@@ -4,10 +4,10 @@
  */
 interface IBitmapFieldInfo {
   /** Bit offset from LSB */
-  offset: number;
+  readonly offset: number;
 
   /** Width in bits */
-  width: number;
+  readonly width: number;
 }
 
 export default IBitmapFieldInfo;

package/src/transpiler/types/symbols/IBitmapSymbol.ts

@@ -0,0 +1,21 @@
+import type IBaseSymbol from "./IBaseSymbol";
+import type IBitmapFieldInfo from "./IBitmapFieldInfo";
+
+/**
+ * Symbol representing a bitmap type definition.
+ */
+interface IBitmapSymbol extends IBaseSymbol {
+  /** Discriminator narrowed to "bitmap" */
+  readonly kind: "bitmap";
+
+  /** Backing integer type (e.g., "u8", "u32") */
+  readonly backingType: string;
+
+  /** Total bit width of the bitmap */
+  readonly bitWidth: number;
+
+  /** Map of field name to bit offset/width metadata */
+  readonly fields: ReadonlyMap<string, IBitmapFieldInfo>;
+}
+
+export default IBitmapSymbol;

package/src/transpiler/{logic/symbols/types → types/symbols}/IEnumSymbol.ts

@@ -1,18 +1,17 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
+import type IBaseSymbol from "./IBaseSymbol";
 
 /**
  * Symbol representing an enum type definition.
  */
 interface IEnumSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Enum;
+  /** Discriminator narrowed to "enum" */
+  readonly kind: "enum";
 
   /** Map of member name to numeric value */
-  members: Map<string, number>;
+  readonly members: ReadonlyMap<string, number>;
 
   /** Optional explicit bit width (e.g., 8 for u8 backing type) */
-  bitWidth?: number;
+  readonly bitWidth?: number;
 }
 
 export default IEnumSymbol;

package/src/transpiler/types/symbols/IFieldInfo.ts

@@ -0,0 +1,26 @@
+import type TType from "../TType";
+
+/**
+ * Metadata for a struct field.
+ */
+interface IFieldInfo {
+  /** Field name */
+  readonly name: string;
+
+  /** Field type */
+  readonly type: TType;
+
+  /** Whether this field is const */
+  readonly isConst: boolean;
+
+  /** Whether this field is atomic (volatile in C) */
+  readonly isAtomic: boolean;
+
+  /** Whether this field is an array */
+  readonly isArray: boolean;
+
+  /** Array dimensions if isArray is true */
+  readonly dimensions?: ReadonlyArray<number | string>;
+}
+
+export default IFieldInfo;

package/src/transpiler/types/symbols/IFunctionSymbol.ts

@@ -0,0 +1,30 @@
+import type IBaseSymbol from "./IBaseSymbol";
+import type IScopeSymbol from "./IScopeSymbol";
+import type IParameterInfo from "./IParameterInfo";
+import type TType from "../TType";
+import type TVisibility from "../TVisibility";
+
+/**
+ * Symbol representing a function definition.
+ */
+interface IFunctionSymbol extends IBaseSymbol {
+  /** Discriminator narrowed to "function" */
+  readonly kind: "function";
+
+  /** Scope this function belongs to (overrides IBaseSymbol.scope with specific type) */
+  readonly scope: IScopeSymbol;
+
+  /** Function parameters */
+  readonly parameters: ReadonlyArray<IParameterInfo>;
+
+  /** Return type */
+  readonly returnType: TType;
+
+  /** Visibility within scope */
+  readonly visibility: TVisibility;
+
+  /** AST reference for function body (unknown to avoid parser dependency) */
+  readonly body: unknown;
+}
+
+export default IFunctionSymbol;

package/src/transpiler/types/symbols/IParameterInfo.ts

@@ -0,0 +1,26 @@
+import type TType from "../TType";
+
+/**
+ * Metadata for a function parameter.
+ */
+interface IParameterInfo {
+  /** Parameter name */
+  readonly name: string;
+
+  /** Parameter type */
+  readonly type: TType;
+
+  /** Whether this parameter is const */
+  readonly isConst: boolean;
+
+  /** Whether this parameter is an array */
+  readonly isArray: boolean;
+
+  /** Array dimensions if isArray is true */
+  readonly arrayDimensions?: ReadonlyArray<number | string>;
+
+  /** Issue #268: true if parameter should get auto-const (unmodified pointer) */
+  readonly isAutoConst?: boolean;
+}
+
+export default IParameterInfo;