c-next 0.1.67 → 0.1.69

package/src/transpiler/output/codegen/helpers/__tests__/MemberAccessValidator.test.ts

@@ -118,7 +118,8 @@ describe("MemberAccessValidator", () => {
   });
 
   describe("validateGlobalEntityAccess", () => {
-    it("throws when in scope and entity does not belong to current scope", () => {
+    it("throws when in scope and entity name conflicts with scope member", () => {
+      const scopeMembers = new Map([["Motor", new Set(["Color", "speed"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "Color",
@@ -126,13 +127,29 @@ describe("MemberAccessValidator", () => {
           "enum",
           "Motor",
           false,
+          { scopeMembers },
         ),
       ).toThrow(
         "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor'",
       );
     });
 
-    it("does NOT throw when isGlobalAccess is true", () => {
+    it("does NOT throw when in scope but no naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { scopeMembers },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when isGlobalAccess is true even with conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "Color",
@@ -140,6 +157,7 @@ describe("MemberAccessValidator", () => {
           "enum",
           "Motor",
           true,
+          { scopeMembers },
         ),
       ).not.toThrow();
     });
@@ -168,7 +186,8 @@ describe("MemberAccessValidator", () => {
       ).not.toThrow();
     });
 
-    it("works with register entity type", () => {
+    it("throws for register with naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["GPIO"])]]);
       expect(() =>
         MemberAccessValidator.validateGlobalEntityAccess(
           "GPIO",
@@ -176,10 +195,97 @@ describe("MemberAccessValidator", () => {
           "register",
           "Motor",
           false,
+          { scopeMembers },
         ),
       ).toThrow(
         "Use 'global.GPIO.PIN0' to access register 'GPIO' from inside scope 'Motor'",
       );
     });
+
+    it("does NOT throw for register without naming conflict", () => {
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "GPIO",
+          "PIN0",
+          "register",
+          "Motor",
+          false,
+          { scopeMembers },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when options is undefined", () => {
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          undefined,
+        ),
+      ).not.toThrow();
+    });
+
+    // Shadowing detection tests (using rootIdentifier and knownEnums)
+    it("throws when scope member shadows global enum (resolved identifier differs)", () => {
+      const knownEnums = new Set(["Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color", // resolved to scope member
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).toThrow(
+        "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor' (scope member 'Color' shadows the global enum)",
+      );
+    });
+
+    it("does NOT throw for shadowing when isGlobalAccess is true", () => {
+      const knownEnums = new Set(["Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          true,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when root is not a known enum", () => {
+      const knownEnums = new Set(["OtherEnum"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
+
+    it("does NOT throw when resolved name IS a known enum", () => {
+      const knownEnums = new Set(["Color", "Motor_Color"]);
+      expect(() =>
+        MemberAccessValidator.validateGlobalEntityAccess(
+          "Motor_Color",
+          "Red",
+          "enum",
+          "Motor",
+          false,
+          { rootIdentifier: "Color", knownEnums },
+        ),
+      ).not.toThrow();
+    });
   });
 });

package/src/transpiler/state/CodeGenState.ts

@@ -90,6 +90,13 @@ export default class CodeGenState {
    */
   static symbolTable: SymbolTable = new SymbolTable();
 
+  /**
+   * External struct fields from C/C++ headers for initialization analysis.
+   * Maps struct name -> Set of non-array field names.
+   * Persists across per-file reset() calls, cleared at start of run.
+   */
+  static externalStructFields: Map<string, Set<string>> = new Map();
+
   // ===========================================================================
   // TYPE TRACKING
   // ===========================================================================
@@ -180,7 +187,7 @@ export default class CodeGenState {
   static localArrays: Set<string> = new Set();
 
   /** Scope member names: scope -> Set of member names */
-  static scopeMembers: Map<string, Set<string>> = new Map();
+  private static scopeMembers: Map<string, Set<string>> = new Map();
 
   /** Float bit indexing: declared shadow variables */
   static floatBitShadows: Set<string> = new Set();
@@ -456,6 +463,26 @@ export default class CodeGenState {
     return this.modifiedParameters.get(funcName)?.has(paramName) ?? false;
   }
 
+  /**
+   * Compute unmodified parameters for all functions on-demand.
+   * Returns a map of function name -> Set of parameter names NOT modified.
+   * Computed from functionSignatures and modifiedParameters (no cached state).
+   */
+  static getUnmodifiedParameters(): Map<string, Set<string>> {
+    const result = new Map<string, Set<string>>();
+    for (const [funcName, signature] of this.functionSignatures) {
+      const modifiedSet = this.modifiedParameters.get(funcName);
+      const unmodified = new Set<string>();
+      for (const param of signature.parameters) {
+        if (!modifiedSet?.has(param.name)) {
+          unmodified.add(param.name);
+        }
+      }
+      result.set(funcName, unmodified);
+    }
+    return result;
+  }
+
   /**
    * Check if a parameter should pass by value.
    */
@@ -535,6 +562,20 @@ export default class CodeGenState {
     return this.scopeMembers.get(scopeName);
   }
 
+  /**
+   * Set members of a scope.
+   */
+  static setScopeMembers(scopeName: string, members: Set<string>): void {
+    this.scopeMembers.set(scopeName, members);
+  }
+
+  /**
+   * Get all scope members (for IGeneratorState).
+   */
+  static getAllScopeMembers(): ReadonlyMap<string, ReadonlySet<string>> {
+    return this.scopeMembers;
+  }
+
   /**
    * Check if an identifier is a member of the current scope.
    */
@@ -650,6 +691,39 @@ export default class CodeGenState {
     return this.symbols?.enumMembers.get(enumName);
   }
 
+  /**
+   * Build external struct fields from the symbol table.
+   * Called once per run after all headers are processed.
+   * Issue #355: Excludes array fields from init checking.
+   */
+  static buildExternalStructFields(): void {
+    this.externalStructFields.clear();
+    const allStructFields = this.symbolTable.getAllStructFields();
+
+    for (const [structName, fieldMap] of allStructFields) {
+      const nonArrayFields = new Set<string>();
+      for (const [fieldName, fieldInfo] of fieldMap) {
+        // Only include non-array fields in init checking
+        if (
+          !fieldInfo.arrayDimensions ||
+          fieldInfo.arrayDimensions.length === 0
+        ) {
+          nonArrayFields.add(fieldName);
+        }
+      }
+      if (nonArrayFields.size > 0) {
+        this.externalStructFields.set(structName, nonArrayFields);
+      }
+    }
+  }
+
+  /**
+   * Get external struct fields for initialization analysis.
+   */
+  static getExternalStructFields(): Map<string, Set<string>> {
+    return this.externalStructFields;
+  }
+
   /**
    * Get function return type.
    */

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

@@ -110,7 +110,7 @@ describe("CodeGenState", () => {
 
     it("getScopeMembers returns members for known scope", () => {
       const members = new Set(["member1", "member2"]);
-      CodeGenState.scopeMembers.set("TestScope", members);
+      CodeGenState.setScopeMembers("TestScope", members);
 
       expect(CodeGenState.getScopeMembers("TestScope")).toBe(members);
     });
@@ -122,14 +122,14 @@ describe("CodeGenState", () => {
 
     it("isCurrentScopeMember returns false for non-member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.isCurrentScopeMember("nonMember")).toBe(false);
     });
 
     it("isCurrentScopeMember returns true for member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.isCurrentScopeMember("member1")).toBe(true);
     });
@@ -143,14 +143,14 @@ describe("CodeGenState", () => {
 
     it("returns identifier unchanged when not a scope member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.resolveIdentifier("varName")).toBe("varName");
     });
 
     it("returns scoped name for scope member", () => {
       CodeGenState.currentScope = "TestScope";
-      CodeGenState.scopeMembers.set("TestScope", new Set(["member1"]));
+      CodeGenState.setScopeMembers("TestScope", new Set(["member1"]));
 
       expect(CodeGenState.resolveIdentifier("member1")).toBe(
         "TestScope_member1",
@@ -453,4 +453,123 @@ describe("CodeGenState", () => {
       expect(CodeGenState.isLocalArray("myArr")).toBe(true);
     });
   });
+
+  describe("buildExternalStructFields", () => {
+    it("returns empty map when no struct fields exist", () => {
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+      expect(result.size).toBe(0);
+    });
+
+    it("includes non-array fields in result", () => {
+      // Manually add struct fields to the symbol table
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const pointFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      pointFields.set("x", { type: "i32" });
+      pointFields.set("y", { type: "i32" });
+      structFields.set("Point", pointFields);
+
+      // Use restoreStructFields to populate the symbol table
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      expect(result.has("Point")).toBe(true);
+      const fields = result.get("Point");
+      expect(fields?.has("x")).toBe(true);
+      expect(fields?.has("y")).toBe(true);
+    });
+
+    it("excludes array fields from result (Issue #355)", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const bufferFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      bufferFields.set("size", { type: "u32" }); // Non-array
+      bufferFields.set("data", { type: "u8", arrayDimensions: [256] }); // Array
+
+      structFields.set("Buffer", bufferFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      expect(result.has("Buffer")).toBe(true);
+      const fields = result.get("Buffer");
+      expect(fields?.has("size")).toBe(true); // Non-array included
+      expect(fields?.has("data")).toBe(false); // Array excluded
+    });
+
+    it("excludes structs with only array fields", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+      const arrayOnlyFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      arrayOnlyFields.set("items", { type: "u8", arrayDimensions: [10] });
+      arrayOnlyFields.set("values", { type: "i32", arrayDimensions: [5] });
+
+      structFields.set("ArrayOnly", arrayOnlyFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      // Struct should not be included since all fields are arrays
+      expect(result.has("ArrayOnly")).toBe(false);
+    });
+
+    it("handles mixed structs correctly", () => {
+      const structFields = new Map<
+        string,
+        Map<string, { type: string; arrayDimensions?: number[] }>
+      >();
+
+      // Struct with mixed fields
+      const mixedFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      mixedFields.set("id", { type: "u32" });
+      mixedFields.set("name", { type: "string", arrayDimensions: [32] });
+      mixedFields.set("count", { type: "u16" });
+
+      // Struct with only non-array
+      const simpleFields = new Map<
+        string,
+        { type: string; arrayDimensions?: number[] }
+      >();
+      simpleFields.set("value", { type: "f32" });
+
+      structFields.set("Mixed", mixedFields);
+      structFields.set("Simple", simpleFields);
+      CodeGenState.symbolTable.restoreStructFields(structFields);
+
+      CodeGenState.buildExternalStructFields();
+      const result = CodeGenState.getExternalStructFields();
+
+      // Mixed struct should have only non-array fields
+      expect(result.get("Mixed")?.size).toBe(2);
+      expect(result.get("Mixed")?.has("id")).toBe(true);
+      expect(result.get("Mixed")?.has("count")).toBe(true);
+      expect(result.get("Mixed")?.has("name")).toBe(false);
+
+      // Simple struct should have its field
+      expect(result.get("Simple")?.has("value")).toBe(true);
+    });
+  });
 });

package/src/transpiler/logic/analysis/AnalyzerContextBuilder.ts

@@ -1,58 +0,0 @@
-/**
- * AnalyzerContextBuilder
- * Issue #591: Extracted from Transpiler.transpileSource() to reduce complexity
- *
- * Builds the context needed for running semantic analyzers, specifically
- * converting struct field information from the symbol table format to
- * the analyzer-compatible format.
- */
-
-import SymbolTable from "../symbols/SymbolTable";
-
-/**
- * Builds analyzer context from symbol table data.
- *
- * The analyzer requires struct fields as Map<string, Set<string>> (structName -> fieldNames)
- * while the symbol table stores more detailed IStructFieldInfo. This builder handles
- * the conversion, including Issue #355's requirement to exclude array fields.
- */
-class AnalyzerContextBuilder {
-  /**
-   * Build external struct fields map for analyzer from symbol table.
-   *
-   * Converts the symbol table's detailed struct field info to the simpler
-   * format needed by InitializationAnalyzer.
-   *
-   * Issue #355: Excludes array fields from init checking since the analyzer
-   * can't prove loop-based array initialization is complete.
-   *
-   * @param symbolTable - Symbol table containing struct definitions
-   * @returns Map of struct name to set of non-array field names
-   */
-  static buildExternalStructFields(
-    symbolTable: SymbolTable,
-  ): Map<string, Set<string>> {
-    const externalStructFields = new Map<string, Set<string>>();
-    const allStructFields = symbolTable.getAllStructFields();
-
-    for (const [structName, fieldMap] of allStructFields) {
-      const nonArrayFields = new Set<string>();
-      for (const [fieldName, fieldInfo] of fieldMap) {
-        // Only include non-array fields in init checking
-        if (
-          !fieldInfo.arrayDimensions ||
-          fieldInfo.arrayDimensions.length === 0
-        ) {
-          nonArrayFields.add(fieldName);
-        }
-      }
-      if (nonArrayFields.size > 0) {
-        externalStructFields.set(structName, nonArrayFields);
-      }
-    }
-
-    return externalStructFields;
-  }
-}
-
-export default AnalyzerContextBuilder;

package/src/transpiler/logic/analysis/__tests__/AnalyzerContextBuilder.test.ts

@@ -1,137 +0,0 @@
-/**
- * Unit tests for AnalyzerContextBuilder
- * Issue #591: Tests for struct field conversion utility
- */
-
-import { describe, it, expect, beforeEach } from "vitest";
-
-import AnalyzerContextBuilder from "../AnalyzerContextBuilder";
-import SymbolTable from "../../symbols/SymbolTable";
-
-describe("AnalyzerContextBuilder", () => {
-  let symbolTable: SymbolTable;
-
-  beforeEach(() => {
-    symbolTable = new SymbolTable();
-  });
-
-  describe("buildExternalStructFields", () => {
-    it("returns empty map when no struct fields exist", () => {
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.size).toBe(0);
-    });
-
-    it("includes non-array fields in result", () => {
-      // Manually add struct fields to the symbol table
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const pointFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      pointFields.set("x", { type: "i32" });
-      pointFields.set("y", { type: "i32" });
-      structFields.set("Point", pointFields);
-
-      // Use restoreStructFields to populate the symbol table
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.has("Point")).toBe(true);
-      const fields = result.get("Point");
-      expect(fields?.has("x")).toBe(true);
-      expect(fields?.has("y")).toBe(true);
-    });
-
-    it("excludes array fields from result (Issue #355)", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const bufferFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      bufferFields.set("size", { type: "u32" }); // Non-array
-      bufferFields.set("data", { type: "u8", arrayDimensions: [256] }); // Array
-
-      structFields.set("Buffer", bufferFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      expect(result.has("Buffer")).toBe(true);
-      const fields = result.get("Buffer");
-      expect(fields?.has("size")).toBe(true); // Non-array included
-      expect(fields?.has("data")).toBe(false); // Array excluded
-    });
-
-    it("excludes structs with only array fields", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const arrayOnlyFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      arrayOnlyFields.set("items", { type: "u8", arrayDimensions: [10] });
-      arrayOnlyFields.set("values", { type: "i32", arrayDimensions: [5] });
-
-      structFields.set("ArrayOnly", arrayOnlyFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      // Struct should not be included since all fields are arrays
-      expect(result.has("ArrayOnly")).toBe(false);
-    });
-
-    it("handles mixed structs correctly", () => {
-      const structFields = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-
-      // Struct with mixed fields
-      const mixedFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      mixedFields.set("id", { type: "u32" });
-      mixedFields.set("name", { type: "string", arrayDimensions: [32] });
-      mixedFields.set("count", { type: "u16" });
-
-      // Struct with only non-array
-      const simpleFields = new Map<
-        string,
-        { type: string; arrayDimensions?: number[] }
-      >();
-      simpleFields.set("value", { type: "f32" });
-
-      structFields.set("Mixed", mixedFields);
-      structFields.set("Simple", simpleFields);
-      symbolTable.restoreStructFields(structFields);
-
-      const result =
-        AnalyzerContextBuilder.buildExternalStructFields(symbolTable);
-
-      // Mixed struct should have only non-array fields
-      expect(result.get("Mixed")?.size).toBe(2);
-      expect(result.get("Mixed")?.has("id")).toBe(true);
-      expect(result.get("Mixed")?.has("count")).toBe(true);
-      expect(result.get("Mixed")?.has("name")).toBe(false);
-
-      // Simple struct should have its field
-      expect(result.get("Simple")?.has("value")).toBe(true);
-    });
-  });
-});