c-next 0.2.15 → 0.2.17

package/src/transpiler/logic/symbols/SymbolUtils.ts

@@ -14,20 +14,33 @@ const RESERVED_FIELD_NAMES = new Set<string>([]);
 
 /**
  * Parse array dimensions from declarator text using regex.
- * Extracts numeric values from square bracket notation like [8] or [32].
+ * Extracts both numeric values and macro names from square bracket notation.
+ *
+ * Issue #981: Support macro-sized array dimensions like [BUF_SIZE].
+ * Without this, struct fields with macro-sized arrays are incorrectly treated
+ * as non-arrays, causing bit extraction instead of array access.
  *
  * @param text - The declarator text containing array notation
- * @returns Array of dimension sizes, e.g., [8] returns [8], [2][3] returns [2, 3]
+ * @returns Array of dimension sizes (numbers) or macro names (strings),
+ *          e.g., [8] returns [8], [BUF_SIZE] returns ["BUF_SIZE"], [2][N] returns [2, "N"]
  */
-function parseArrayDimensions(text: string): number[] {
-  const dimensions: number[] = [];
-  const arrayMatches = text.match(/\[(\d+)\]/g);
+function parseArrayDimensions(text: string): (number | string)[] {
+  const dimensions: (number | string)[] = [];
+  // Match any bracket content: digits, identifiers, or expressions
+  // Captures: [8], [BUF_SIZE], [N], [SIZE + 1], etc.
+  const arrayMatches = text.match(/\[([^\]]+)\]/g);
 
   if (arrayMatches) {
     for (const match of arrayMatches) {
-      const size = Number.parseInt(match.slice(1, -1), 10);
-      if (!Number.isNaN(size)) {
-        dimensions.push(size);
+      const content = match.slice(1, -1).trim();
+      // Try to parse as numeric first
+      const numericValue = Number.parseInt(content, 10);
+      if (!Number.isNaN(numericValue) && String(numericValue) === content) {
+        // Pure numeric dimension
+        dimensions.push(numericValue);
+      } else {
+        // Macro name or expression - store as string
+        dimensions.push(content);
       }
     }
   }

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -658,6 +658,39 @@ describe("SymbolTable", () => {
       const fields = symbolTable.getStructFields("Point");
       expect(fields?.size).toBe(2);
     });
+
+    it("Issue #981: addCSymbol should register struct fields with macro dimensions", () => {
+      // When a C struct with macro-sized array fields is added via addCSymbol,
+      // the fields should be registered in structFields for getMemberTypeInfo lookups
+      const cStructSymbol: TCSymbol = {
+        kind: "struct",
+        name: "msg_t",
+        sourceFile: "fake_lib.h",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.C,
+        isExported: true,
+        isUnion: false,
+        fields: new Map([
+          [
+            "data",
+            { name: "data", type: "uint8_t", arrayDimensions: ["BUF_SIZE"] },
+          ],
+        ]),
+      };
+
+      symbolTable.addCSymbol(cStructSymbol);
+
+      // Struct fields should now be registered
+      const fields = symbolTable.getStructFields("msg_t");
+      expect(fields).toBeDefined();
+      expect(fields?.size).toBe(1);
+
+      // Field info should include the macro-sized array dimension
+      const dataField = symbolTable.getStructFieldInfo("msg_t", "data");
+      expect(dataField).toBeDefined();
+      expect(dataField?.type).toBe("uint8_t");
+      expect(dataField?.arrayDimensions).toEqual(["BUF_SIZE"]);
+    });
   });
 
   // ========================================================================
@@ -752,14 +785,16 @@ describe("SymbolTable", () => {
       expect(symbolTable.isTypedefStructType("other_t")).toBe(false);
     });
 
-    it("should always return true for typedef struct types (additive only)", () => {
-      // Issue #958: typedef struct types are never unmarked
+    it("should return false when underlying struct tag has body (issue #948)", () => {
+      // Issue #948: Query-time resolution - if the underlying struct tag
+      // has a full body definition, this is NOT an external typedef struct
       symbolTable.markTypedefStructType("point_t", "point.h");
       expect(symbolTable.isTypedefStructType("point_t")).toBe(true);
-      // Even after marking the body, typedef struct type stays marked
+      // After marking the body, typedef struct type should return false
+      // because it's now a complete type (value semantics, not pointer)
       symbolTable.registerStructTagAlias("_point", "point_t");
       symbolTable.markStructTagHasBody("_point");
-      expect(symbolTable.isTypedefStructType("point_t")).toBe(true);
+      expect(symbolTable.isTypedefStructType("point_t")).toBe(false);
     });
 
     it("should get all typedef struct types", () => {

package/src/transpiler/logic/symbols/__tests__/SymbolUtils.test.ts

@@ -33,9 +33,10 @@ describe("SymbolUtils", () => {
       expect(SymbolUtils.parseArrayDimensions("uint8_t data[10];")).toEqual([
         10,
       ]);
+      // Issue #981: macro-sized arrays are captured as strings
       expect(
         SymbolUtils.parseArrayDimensions("char buffer[BUFFER_SIZE]"),
-      ).toEqual([]);
+      ).toEqual(["BUFFER_SIZE"]);
     });
   });
 

package/src/transpiler/logic/symbols/c/utils/DeclaratorUtils.ts

@@ -131,8 +131,9 @@ class DeclaratorUtils {
 
   /**
    * Extract array dimensions from a declarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
-  static extractArrayDimensions(declarator: any): number[] {
+  static extractArrayDimensions(declarator: any): (number | string)[] {
     const directDecl = declarator.directDeclarator?.();
     if (!directDecl) return [];
 

package/src/transpiler/logic/symbols/cnext/__tests__/CNextResolver.integration.test.ts

@@ -95,14 +95,15 @@ describe("CNextResolver Integration", () => {
 
   describe("scope handling", () => {
     it("resolves scope with members", () => {
+      // ADR-016: Functions are public by default, variables are private by default
       const code = `
         scope Motor {
           u32 position;
 
-          public void init() {
+          void init() {
           }
 
-          void update() {
+          private void update() {
           }
         }
       `;
@@ -122,6 +123,7 @@ describe("CNextResolver Integration", () => {
       expect(SymbolGuards.isVariable(positionVar!)).toBe(true);
       expect(positionVar!.scope.name).toBe("Motor");
 
+      // init() is public by default (no modifier needed)
       const initFunc = symbols.find((s) => s.name === "init");
       expect(initFunc).toBeDefined();
       if (SymbolGuards.isFunction(initFunc!)) {
@@ -129,6 +131,7 @@ describe("CNextResolver Integration", () => {
         expect(initFunc.scope.name).toBe("Motor");
       }
 
+      // update() has explicit 'private' keyword
       const updateFunc = symbols.find((s) => s.name === "update");
       expect(updateFunc).toBeDefined();
       if (SymbolGuards.isFunction(updateFunc!)) {

package/src/transpiler/logic/symbols/cnext/__tests__/ScopeCollector.test.ts

@@ -32,11 +32,12 @@ describe("ScopeCollector", () => {
     });
 
     it("collects scope with functions", () => {
+      // ADR-016: Functions are public by default, use explicit 'private' for internal functions
       const code = `
         scope Motor {
-          public void init() {
+          void init() {
           }
-          void update() {
+          private void update() {
           }
         }
       `;
@@ -45,7 +46,9 @@ describe("ScopeCollector", () => {
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", new Set());
 
       expect(result.scopeSymbol.members).toEqual(["init", "update"]);
+      // init() is public by default (no modifier)
       expect(result.scopeSymbol.memberVisibility.get("init")).toBe("public");
+      // update() has explicit 'private' keyword
       expect(result.scopeSymbol.memberVisibility.get("update")).toBe("private");
 
       expect(result.memberSymbols.length).toBe(2);

package/src/transpiler/logic/symbols/cnext/collectors/ScopeCollector.ts

@@ -8,6 +8,7 @@
 
 import * as Parser from "../../../parser/grammar/CNextParser";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ScopeUtils from "../../../../../utils/ScopeUtils";
 import TSymbol from "../../../../types/symbols/TSymbol";
 import TVisibility from "../../../../types/TVisibility";
 import IScopeCollectorResult from "../types/IScopeCollectorResult";
@@ -69,10 +70,14 @@ class ScopeCollector {
     const memberSymbols: TSymbol[] = [];
 
     for (const member of ctx.scopeMember()) {
-      // ADR-016: Extract visibility (private by default)
+      // ADR-016: Extract visibility with member-type-aware defaults
       const visibilityMod = member.visibilityModifier();
+      const explicitVisibility = visibilityMod?.getText() as
+        | TVisibility
+        | undefined;
+      const isFunction = member.functionDeclaration() !== null;
       const visibility: TVisibility =
-        (visibilityMod?.getText() as TVisibility) ?? "private";
+        explicitVisibility ?? ScopeUtils.getDefaultVisibility(isFunction);
       const isPublic = visibility === "public";
 
       // Handle variable declarations

package/src/transpiler/logic/symbols/cnext/collectors/VariableCollector.ts

@@ -75,16 +75,28 @@ class VariableCollector {
   }
 
   /**
-   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr).
+   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr, u16[] arr).
+   * Handles size inference from initializer when dimension is empty.
    */
   private static collectArrayTypeDimensions(
     arrayTypeCtx: Parser.ArrayTypeContext,
     constValues: Map<string, number> | undefined,
+    initExpr: Parser.ExpressionContext | null,
   ): (number | string)[] {
     const dimensions: (number | string)[] = [];
     for (const dim of arrayTypeCtx.arrayTypeDimension()) {
       const sizeExpr = dim.expression();
-      if (!sizeExpr) continue;
+
+      if (!sizeExpr) {
+        // Issue #636: Empty dimension [] - infer size from array initializer
+        if (initExpr) {
+          const inferredSize = ArrayInitializerUtils.getInferredSize(initExpr);
+          if (inferredSize !== undefined) {
+            dimensions.push(inferredSize);
+          }
+        }
+        continue;
+      }
 
       const dimText = sizeExpr.getText();
       const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
@@ -146,6 +158,7 @@ class VariableCollector {
         ...VariableCollector.collectArrayTypeDimensions(
           arrayTypeCtx,
           constValues,
+          initExpr,
         ),
       );
     }

package/src/transpiler/logic/symbols/cnext/utils/TypeUtils.ts

@@ -6,14 +6,16 @@ import * as Parser from "../../../parser/grammar/CNextParser";
 import CNEXT_TO_C_TYPE_MAP from "../../../../../utils/constants/TypeMappings";
 
 /**
- * Resolve scoped type (this.Type) to full name.
+ * Common interface for type contexts that share the same type accessors.
+ * Both TypeContext and ArrayTypeContext have these methods.
  */
-function resolveScopedType(
-  scopedTypeCtx: Parser.ScopedTypeContext,
-  scopeName?: string,
-): string {
-  const typeName = scopedTypeCtx.IDENTIFIER().getText();
-  return scopeName ? `${scopeName}_${typeName}` : typeName;
+interface ITypeAccessors {
+  primitiveType(): Parser.PrimitiveTypeContext | null;
+  userType(): Parser.UserTypeContext | null;
+  stringType(): Parser.StringTypeContext | null;
+  scopedType(): Parser.ScopedTypeContext | null;
+  qualifiedType(): Parser.QualifiedTypeContext | null;
+  globalType(): Parser.GlobalTypeContext | null;
 }
 
 /**
@@ -25,19 +27,50 @@ function resolveStringType(stringCtx: Parser.StringTypeContext): string {
 }
 
 /**
- * Extract inner type from arrayType context.
+ * Dispatch type resolution for contexts that share common type accessors.
+ * Handles scoped, qualified, global, primitive, string, and user types.
+ * Used by both bare type contexts and array element type contexts.
+ *
+ * @returns The resolved type name, or null if no matching type accessor found
  */
-function resolveArrayInnerType(arrayTypeCtx: Parser.ArrayTypeContext): string {
-  if (arrayTypeCtx.primitiveType()) {
-    return arrayTypeCtx.primitiveType()!.getText();
+function dispatchTypeResolution(
+  accessors: ITypeAccessors,
+  scopeName?: string,
+): string | null {
+  // Handle this.Type for scoped types (e.g., this.State -> Motor_State)
+  if (accessors.scopedType()) {
+    const typeName = accessors.scopedType()!.IDENTIFIER().getText();
+    return scopeName ? `${scopeName}_${typeName}` : typeName;
+  }
+
+  // Handle global.Type for global types inside scope
+  // global.ECategory -> ECategory (just the type name, no scope prefix)
+  if (accessors.globalType()) {
+    return accessors.globalType()!.IDENTIFIER().getText();
   }
-  if (arrayTypeCtx.userType()) {
-    return arrayTypeCtx.userType()!.getText();
+
+  // Handle Scope.Type from outside scope (e.g., Motor.State -> Motor_State)
+  if (accessors.qualifiedType()) {
+    const identifiers = accessors.qualifiedType()!.IDENTIFIER();
+    return identifiers.map((id) => id.getText()).join("_");
+  }
+
+  // Handle user-defined types
+  if (accessors.userType()) {
+    return accessors.userType()!.getText();
   }
-  // Fallback for other nested types - strip the dimension part
-  const text = arrayTypeCtx.getText();
-  const bracketIdx = text.indexOf("[");
-  return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+
+  // Handle primitive types
+  if (accessors.primitiveType()) {
+    return accessors.primitiveType()!.getText();
+  }
+
+  // Handle string types - preserve capacity for validation (Issue #139)
+  if (accessors.stringType()) {
+    return resolveStringType(accessors.stringType()!);
+  }
+
+  return null;
 }
 
 class TypeUtils {
@@ -56,42 +89,23 @@ class TypeUtils {
   ): string {
     if (!ctx) return "void";
 
-    // Handle this.Type for scoped types (e.g., this.State -> Motor_State)
-    if (ctx.scopedType()) {
-      return resolveScopedType(ctx.scopedType()!, scopeName);
-    }
-
-    // Issue #478: Handle global.Type for global types inside scope
-    // global.ECategory -> ECategory (just the type name, no scope prefix)
-    if (ctx.globalType()) {
-      return ctx.globalType()!.IDENTIFIER().getText();
-    }
-
-    // Handle Scope.Type from outside scope (e.g., Motor.State -> Motor_State)
-    if (ctx.qualifiedType()) {
-      const identifiers = ctx.qualifiedType()!.IDENTIFIER();
-      return identifiers.map((id) => id.getText()).join("_");
-    }
-
-    // Handle user-defined types
-    if (ctx.userType()) {
-      return ctx.userType()!.getText();
-    }
-
-    // Handle primitive types
-    if (ctx.primitiveType()) {
-      return ctx.primitiveType()!.getText();
-    }
-
-    // Handle string types - preserve capacity for validation (Issue #139)
-    if (ctx.stringType()) {
-      return resolveStringType(ctx.stringType()!);
-    }
-
     // Handle arrayType: Type[size] - extract the inner type without dimension
     // The dimension is tracked separately in arrayDimensions
     if (ctx.arrayType()) {
-      return resolveArrayInnerType(ctx.arrayType()!);
+      const result = dispatchTypeResolution(ctx.arrayType()!, scopeName);
+      if (result !== null) {
+        return result;
+      }
+      // Fallback for unrecognized array types - strip the dimension part
+      const text = ctx.arrayType()!.getText();
+      const bracketIdx = text.indexOf("[");
+      return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+    }
+
+    // Non-array types - dispatch directly
+    const result = dispatchTypeResolution(ctx, scopeName);
+    if (result !== null) {
+      return result;
     }
 
     // Fallback

package/src/transpiler/logic/symbols/cpp/utils/DeclaratorUtils.ts

@@ -217,8 +217,9 @@ class DeclaratorUtils {
 
   /**
    * Extract array dimensions from a declarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
-  static extractArrayDimensions(declarator: any): number[] {
+  static extractArrayDimensions(declarator: any): (number | string)[] {
     // For C++, we need to check both pointer and no-pointer declarators
     const ptrDecl = declarator.pointerDeclarator?.();
     if (ptrDecl) {
@@ -238,8 +239,9 @@ class DeclaratorUtils {
 
   /**
    * Extract array dimensions from a noPointerDeclarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
-  static extractArrayDimensionsFromNoPtr(noPtr: any): number[] {
+  static extractArrayDimensionsFromNoPtr(noPtr: any): (number | string)[] {
     // Use shared utility for regex-based extraction
     return SymbolUtils.parseArrayDimensions(noPtr.getText());
   }