c-next 0.1.67 → 0.1.69

package/src/transpiler/output/codegen/assignment/handlers/ArrayHandlers.ts

@@ -20,26 +20,30 @@ function gen(): ICodeGenApi {
 
 /**
  * Handle simple array element: arr[i] <- value
+ *
+ * Uses resolvedTarget which includes scope prefix and subscript,
+ * e.g., "data[0]" inside scope ArrayBug -> "ArrayBug_data[0]"
  */
 function handleArrayElement(ctx: IAssignmentContext): string {
-  const name = ctx.identifiers[0];
-  const index = gen().generateExpression(ctx.subscripts[0]);
-
-  return `${name}[${index}] ${ctx.cOp} ${ctx.generatedValue};`;
+  return `${ctx.resolvedTarget} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
 /**
  * Handle multi-dimensional array element: matrix[i][j] <- value
+ *
+ * Uses resolvedTarget which includes scope prefix and all subscripts.
+ * Uses resolvedBaseIdentifier for type lookups to support scoped arrays.
  */
 function handleMultiDimArrayElement(ctx: IAssignmentContext): string {
-  const name = ctx.identifiers[0];
-  const typeInfo = CodeGenState.typeRegistry.get(name);
+  // Use resolvedBaseIdentifier for type lookup (includes scope prefix)
+  // e.g., "ArrayBug_data" instead of "data"
+  const typeInfo = CodeGenState.typeRegistry.get(ctx.resolvedBaseIdentifier);
 
   // ADR-036: Compile-time bounds checking for constant indices
   if (typeInfo?.arrayDimensions) {
     const line = ctx.subscripts[0]?.start?.line ?? 0;
     TypeValidator.checkArrayBounds(
-      name,
+      ctx.resolvedBaseIdentifier,
       [...typeInfo.arrayDimensions],
       [...ctx.subscripts],
       line,
@@ -47,11 +51,7 @@ function handleMultiDimArrayElement(ctx: IAssignmentContext): string {
     );
   }
 
-  const indices = ctx.subscripts
-    .map((e) => gen().generateExpression(e))
-    .join("][");
-
-  return `${name}[${indices}] ${ctx.cOp} ${ctx.generatedValue};`;
+  return `${ctx.resolvedTarget} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
 /**
@@ -69,7 +69,8 @@ function handleArraySlice(ctx: IAssignmentContext): string {
     );
   }
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup (includes scope prefix)
+  const name = ctx.resolvedBaseIdentifier;
   const typeInfo = CodeGenState.typeRegistry.get(name);
 
   // Get line number for error messages
@@ -77,10 +78,12 @@ function handleArraySlice(ctx: IAssignmentContext): string {
 
   // Validate 1D array only
   if (typeInfo?.arrayDimensions && typeInfo.arrayDimensions.length > 1) {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
       `${line}:0 Error: Slice assignment is only valid on one-dimensional arrays. ` +
-        `'${name}' has ${typeInfo.arrayDimensions.length} dimensions. ` +
-        `Access the innermost dimension first (e.g., ${name}[index][offset, length]).`,
+        `'${rawName}' has ${typeInfo.arrayDimensions.length} dimensions. ` +
+        `Access the innermost dimension first (e.g., ${rawName}[index][offset, length]).`,
     );
   }
 
@@ -109,17 +112,21 @@ function handleArraySlice(ctx: IAssignmentContext): string {
   } else if (typeInfo?.arrayDimensions?.[0]) {
     capacity = typeInfo.arrayDimensions[0];
   } else {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
-      `${line}:0 Error: Cannot determine buffer size for '${name}' at compile time.`,
+      `${line}:0 Error: Cannot determine buffer size for '${rawName}' at compile time.`,
     );
   }
 
   // Bounds validation
   if (offsetValue + lengthValue > capacity) {
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
     throw new Error(
       `${line}:0 Error: Slice assignment out of bounds: ` +
         `offset(${offsetValue}) + length(${lengthValue}) = ${offsetValue + lengthValue} ` +
-        `exceeds buffer capacity(${capacity}) for '${name}'.`,
+        `exceeds buffer capacity(${capacity}) for '${rawName}'.`,
     );
   }
 

package/src/transpiler/output/codegen/assignment/handlers/BitAccessHandlers.ts

@@ -33,11 +33,14 @@ function validateNotCompound(ctx: IAssignmentContext): void {
 /**
  * Handle single bit on integer variable: flags[3] <- true
  * Also handles float bit indexing: f32Var[3] <- true
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleIntegerBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  // e.g., "ArrayBug_flags" instead of "flags"
+  const name = ctx.resolvedBaseIdentifier;
   const bitIndex = gen().generateExpression(ctx.subscripts[0]);
   const typeInfo = CodeGenState.typeRegistry.get(name);
 
@@ -67,11 +70,13 @@ function handleIntegerBit(ctx: IAssignmentContext): string {
 /**
  * Handle bit range on integer variable: flags[0, 3] <- 5
  * Also handles float bit range: f32Var[0, 8] <- 0xFF
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleIntegerBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const name = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  const name = ctx.resolvedBaseIdentifier;
   const start = gen().generateExpression(ctx.subscripts[0]);
   const width = gen().generateExpression(ctx.subscripts[1]);
   const typeInfo = CodeGenState.typeRegistry.get(name);
@@ -126,15 +131,19 @@ function handleStructMemberBit(ctx: IAssignmentContext): string {
 
 /**
  * Handle bit on multi-dimensional array element: matrix[i][j][FIELD_BIT] <- false
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleArrayElementBit(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
-  const arrayName = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for type lookup and code generation
+  const arrayName = ctx.resolvedBaseIdentifier;
   const typeInfo = CodeGenState.typeRegistry.get(arrayName);
 
   if (!typeInfo?.arrayDimensions) {
-    throw new Error(`Error: ${arrayName} is not an array`);
+    // Use raw identifier in error message for clarity
+    const rawName = ctx.identifiers[0];
+    throw new Error(`Error: ${rawName} is not an array`);
   }
 
   const numDims = typeInfo.arrayDimensions.length;
@@ -160,12 +169,14 @@ function handleArrayElementBit(ctx: IAssignmentContext): string {
  *
  * The target is a chain like array[idx].member or struct.field with a
  * bit range subscript [start, width] at the end.
+ * Uses resolvedBaseIdentifier for proper scope prefix support.
  */
 function handleStructChainBitRange(ctx: IAssignmentContext): string {
   validateNotCompound(ctx);
 
   // Build the base target from postfixOps, excluding the last one (the bit range)
-  const baseId = ctx.identifiers[0];
+  // Use resolvedBaseIdentifier for the base to include scope prefix
+  const baseId = ctx.resolvedBaseIdentifier;
   const opsBeforeLast = ctx.postfixOps.slice(0, -1);
 
   let baseTarget = baseId;

package/src/transpiler/output/codegen/assignment/handlers/__tests__/AccessPatternHandlers.test.ts

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["Counter", "value"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers.join("_")}`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["Counter", "value"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/ArrayHandlers.test.ts

@@ -28,8 +28,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["arr"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers[0]}[i]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["arr"],
+    identifiers,
     subscripts: [{ mockValue: "i", start: { line: 1 } } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -46,6 +52,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }
@@ -96,6 +104,7 @@ describe("ArrayHandlers", () => {
         isCompound: true,
         cnextOp: "+<-",
         cOp: "+=",
+        resolvedTarget: "arr[0]",
       });
 
       const result = getHandler()!(ctx);
@@ -109,6 +118,8 @@ describe("ArrayHandlers", () => {
       });
       const ctx = createMockContext({
         identifiers: ["buffer"],
+        resolvedTarget: "buffer[idx]",
+        resolvedBaseIdentifier: "buffer",
       });
 
       const result = getHandler()!(ctx);
@@ -137,6 +148,8 @@ describe("ArrayHandlers", () => {
           { mockValue: "j", start: { line: 1 } } as never,
         ],
         subscriptDepth: 2,
+        resolvedTarget: "matrix[i][j]",
+        resolvedBaseIdentifier: "matrix",
       });
 
       const result = getHandler()!(ctx);
@@ -160,6 +173,8 @@ describe("ArrayHandlers", () => {
           { mockValue: "z", start: { line: 1 } } as never,
         ],
         subscriptDepth: 3,
+        resolvedTarget: "cube[x][y][z]",
+        resolvedBaseIdentifier: "cube",
       });
 
       const result = getHandler()!(ctx);
@@ -212,6 +227,8 @@ describe("ArrayHandlers", () => {
         ],
         isCompound: true,
         cOp: "-=",
+        resolvedTarget: "grid[0][1]",
+        resolvedBaseIdentifier: "grid",
       });
 
       const result = getHandler()!(ctx);

package/src/transpiler/output/codegen/assignment/handlers/__tests__/BitAccessHandlers.test.ts

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["flags"];
+  const resolvedTarget = overrides.resolvedTarget ?? `${identifiers[0]}[3]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["flags"],
+    identifiers,
     subscripts: [{ mockValue: "3" } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/BitmapHandlers.test.ts

@@ -25,8 +25,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["flags", "Running"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["flags", "Running"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
@@ -44,6 +50,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/RegisterHandlers.test.ts

@@ -16,8 +16,15 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["GPIO7", "DR_SET"];
+  const resolvedTarget =
+    overrides.resolvedTarget ?? `${identifiers.join("_")}[LED_BIT]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["GPIO7", "DR_SET"],
+    identifiers,
     subscripts: [{ mockValue: "LED_BIT" } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +41,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/SpecialHandlers.test.ts

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["counter"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["counter"],
+    identifiers,
     subscripts: [],
     isCompound: true,
     cnextOp: "+<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: true,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/StringHandlers.test.ts

@@ -16,14 +16,22 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["testVar"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["testVar"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
     cOp: "=",
     generatedValue: '"hello"',
     targetCtx: {} as never,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -1441,16 +1441,33 @@ const generateMemberAccess = (
   state: IGeneratorState,
   orchestrator: IOrchestrator,
   effects: TGeneratorEffect[],
-): MemberAccessResult =>
-  tryBitmapFieldAccess(ctx, input, effects) ??
-  tryScopeMemberAccess(ctx, input, state, orchestrator) ??
-  tryKnownScopeAccess(ctx, input, state, orchestrator) ??
-  tryEnumMemberAccess(ctx, input, state, orchestrator) ??
-  tryRegisterMemberAccess(ctx, input, state) ??
-  tryStructParamAccess(ctx, orchestrator) ??
-  tryRegisterBitmapAccess(ctx, input, effects) ??
-  tryStructBitmapAccess(ctx, input, effects) ??
-  generateDefaultAccess(ctx, orchestrator);
+): MemberAccessResult => {
+  // Check for enum shadowing before dispatch - catches case where identifier
+  // was resolved to a scope member that shadows a global enum
+  MemberAccessValidator.validateGlobalEntityAccess(
+    ctx.result,
+    ctx.memberName,
+    "enum",
+    state.currentScope,
+    ctx.isGlobalAccess,
+    {
+      rootIdentifier: ctx.rootIdentifier,
+      knownEnums: input.symbols!.knownEnums,
+    },
+  );
+
+  return (
+    tryBitmapFieldAccess(ctx, input, effects) ??
+    tryScopeMemberAccess(ctx, input, state, orchestrator) ??
+    tryKnownScopeAccess(ctx, input, state, orchestrator) ??
+    tryEnumMemberAccess(ctx, input, state, orchestrator) ??
+    tryRegisterMemberAccess(ctx, input, state) ??
+    tryStructParamAccess(ctx, orchestrator) ??
+    tryRegisterBitmapAccess(ctx, input, effects) ??
+    tryStructBitmapAccess(ctx, input, effects) ??
+    generateDefaultAccess(ctx, orchestrator)
+  );
+};
 
 // ========================================================================
 // Member Access Handlers
@@ -1575,12 +1592,15 @@ const tryEnumMemberAccess = (
     return null;
   }
 
+  // Shadowing check already done in generateMemberAccess; this catches
+  // direct conflicts where ctx.result is the enum name (no resolution happened)
   MemberAccessValidator.validateGlobalEntityAccess(
     ctx.result,
     ctx.memberName,
     "enum",
     state.currentScope,
     ctx.isGlobalAccess,
+    { scopeMembers: state.scopeMembers },
   );
 
   const output = initializeMemberOutput(ctx);
@@ -1606,6 +1626,7 @@ const tryRegisterMemberAccess = (
     "register",
     state.currentScope,
     ctx.isGlobalAccess,
+    { scopeMembers: state.scopeMembers },
   );
 
   MemberAccessValidator.validateRegisterReadAccess(

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -1318,7 +1318,7 @@ describe("PostfixExpressionGenerator", () => {
       expect(result.code).toBe("Color_Red");
     });
 
-    it("throws when accessing enum without global prefix inside scope", () => {
+    it("throws when accessing enum with naming conflict inside scope", () => {
       const symbols = createMockSymbols({
         knownEnums: new Set(["Color"]),
       });
@@ -1326,7 +1326,8 @@ describe("PostfixExpressionGenerator", () => {
         createMockPostfixOp({ identifier: "Red" }),
       ]);
       const input = createMockInput({ symbols });
-      const state = createMockState({ currentScope: "Motor" });
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
       const orchestrator = createMockOrchestrator({
         generatePrimaryExpr: () => "Color",
         getScopeSeparator: () => "_",
@@ -1336,6 +1337,48 @@ describe("PostfixExpressionGenerator", () => {
         generatePostfixExpression(ctx, input, state, orchestrator),
       ).toThrow("Use 'global.Color.Red' to access enum 'Color'");
     });
+
+    it("allows enum access without global prefix when no naming conflict", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const ctx = createMockPostfixExpressionContext("Color", [
+        createMockPostfixOp({ identifier: "Red" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "Color",
+        getScopeSeparator: () => "_",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("Color_Red");
+    });
+
+    it("throws when scope member shadows global enum (resolved identifier differs)", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const ctx = createMockPostfixExpressionContext("Color", [
+        createMockPostfixOp({ identifier: "Red" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["Color"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        // Simulates identifier resolution: Color -> Motor_Color (scope member)
+        generatePrimaryExpr: () => "Motor_Color",
+        getScopeSeparator: () => "_",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(
+        "Use 'global.Color.Red' to access enum 'Color' from inside scope 'Motor' (scope member 'Color' shadows the global enum)",
+      );
+    });
   });
 
   describe("register member access", () => {
@@ -1375,7 +1418,7 @@ describe("PostfixExpressionGenerator", () => {
       ).toThrow("cannot read from write-only register member 'DATA'");
     });
 
-    it("throws when accessing register without global prefix inside scope", () => {
+    it("throws when accessing register with naming conflict inside scope", () => {
       const symbols = createMockSymbols({
         knownRegisters: new Set(["GPIO"]),
       });
@@ -1383,7 +1426,8 @@ describe("PostfixExpressionGenerator", () => {
         createMockPostfixOp({ identifier: "PIN0" }),
       ]);
       const input = createMockInput({ symbols });
-      const state = createMockState({ currentScope: "Motor" });
+      const scopeMembers = new Map([["Motor", new Set(["GPIO"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
       const orchestrator = createMockOrchestrator({
         generatePrimaryExpr: () => "GPIO",
       });
@@ -1392,6 +1436,24 @@ describe("PostfixExpressionGenerator", () => {
         generatePostfixExpression(ctx, input, state, orchestrator),
       ).toThrow("Use 'global.GPIO.PIN0' to access register 'GPIO'");
     });
+
+    it("allows register access without global prefix when no naming conflict", () => {
+      const symbols = createMockSymbols({
+        knownRegisters: new Set(["GPIO"]),
+      });
+      const ctx = createMockPostfixExpressionContext("GPIO", [
+        createMockPostfixOp({ identifier: "PIN0" }),
+      ]);
+      const input = createMockInput({ symbols });
+      const scopeMembers = new Map([["Motor", new Set(["speed"])]]);
+      const state = createMockState({ currentScope: "Motor", scopeMembers });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "GPIO",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("GPIO_PIN0");
+    });
   });
 
   describe("struct parameter access", () => {

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

@@ -55,13 +55,22 @@ class MemberAccessValidator {
 
   /**
    * ADR-016/057: Validate that a global entity (enum or register) is accessed
-   * with 'global.' prefix when inside a scope that doesn't own the entity.
+   * with 'global.' prefix when inside a scope that has a naming conflict.
    *
-   * @param entityName - The entity being accessed (e.g., "Color", "GPIO")
+   * Detects two types of conflicts:
+   * 1. Scope member with same name as entity (via scopeMembers lookup)
+   * 2. Identifier was resolved to scope member, shadowing a global enum
+   *    (via rootIdentifier != resolvedName comparison)
+   *
+   * @param entityName - The resolved entity name (e.g., "Color" or "Motor_Color")
    * @param memberName - The member after the entity (e.g., "Red", "PIN0")
    * @param entityType - "enum" or "register" (for error message)
    * @param currentScope - Active scope context (null = not in a scope)
    * @param isGlobalAccess - Whether the access used 'global.' prefix
+   * @param options - Optional conflict detection parameters
+   * @param options.scopeMembers - Map of scope names to their member names
+   * @param options.rootIdentifier - Original identifier before resolution (for shadowing detection)
+   * @param options.knownEnums - Set of known enum names (for shadowing detection)
    */
   static validateGlobalEntityAccess(
     entityName: string,
@@ -69,18 +78,50 @@ class MemberAccessValidator {
     entityType: string,
     currentScope: string | null,
     isGlobalAccess: boolean,
+    options?: {
+      scopeMembers?: ReadonlyMap<string, ReadonlySet<string>>;
+      rootIdentifier?: string;
+      knownEnums?: ReadonlySet<string>;
+    },
   ): void {
     if (isGlobalAccess) {
       return;
     }
-    if (currentScope) {
-      const belongsToCurrentScope = entityName.startsWith(currentScope + "_");
-      if (!belongsToCurrentScope) {
+    if (!currentScope) {
+      return;
+    }
+
+    const { scopeMembers, rootIdentifier, knownEnums } = options ?? {};
+
+    // Check 1: Shadowing detection - identifier was resolved to a scope member
+    // that shadows a global enum. This produces invalid C (e.g., Motor_Color.RED).
+    // This check must run BEFORE the belongsToCurrentScope check because
+    // the resolved name (e.g., Motor_Color) will start with the scope prefix.
+    if (rootIdentifier && knownEnums) {
+      const wasResolved = entityName !== rootIdentifier;
+      const rootIsEnum = knownEnums.has(rootIdentifier);
+      const resolvedIsNotEnum = !knownEnums.has(entityName);
+      if (wasResolved && rootIsEnum && resolvedIsNotEnum) {
         throw new Error(
-          `Error: Use 'global.${entityName}.${memberName}' to access ${entityType} '${entityName}' from inside scope '${currentScope}'`,
+          `Error: Use 'global.${rootIdentifier}.${memberName}' to access enum '${rootIdentifier}' from inside scope '${currentScope}' (scope member '${rootIdentifier}' shadows the global enum)`,
         );
       }
     }
+
+    // Skip check if entity belongs to current scope (e.g., Motor_State in scope Motor)
+    const belongsToCurrentScope = entityName.startsWith(currentScope + "_");
+    if (belongsToCurrentScope) {
+      return;
+    }
+
+    // Check 2: Direct conflict - scope has a member with the same name as the entity
+    const scopeMemberNames = scopeMembers?.get(currentScope);
+    const hasConflict = scopeMemberNames?.has(entityName) ?? false;
+    if (hasConflict) {
+      throw new Error(
+        `Error: Use 'global.${entityName}.${memberName}' to access ${entityType} '${entityName}' from inside scope '${currentScope}'`,
+      );
+    }
   }
 }
 

package/src/transpiler/output/codegen/helpers/MemberSeparatorResolver.ts

@@ -89,7 +89,12 @@ class MemberSeparatorResolver {
     // Scope member access: Sensor.buffer -> Sensor_buffer
     // Works with or without global. prefix (both are valid syntax)
     if (deps.isKnownScope(identifierChain[0])) {
-      deps.validateCrossScopeVisibility(identifierChain[0], memberName);
+      // Issue #779: Skip cross-scope validation for scoped register access
+      // Board.GPIO where Board_GPIO is a known register is valid
+      const scopedRegisterName = `${identifierChain[0]}_${memberName}`;
+      if (!deps.isKnownRegister(scopedRegisterName)) {
+        deps.validateCrossScopeVisibility(identifierChain[0], memberName);
+      }
       return "_";
     }