c-next 0.2.15 → 0.2.17

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

@@ -376,6 +376,7 @@ describe("CodeGenState", () => {
             isArray: false,
             isConst: false,
             isPointer: false,
+            isStruct: false,
             arrayDims: "",
           },
         ],
@@ -1011,25 +1012,35 @@ describe("CodeGenState", () => {
   describe("Opaque Scope Variable Helpers (Issue #948)", () => {
     it("markOpaqueScopeVariable adds to opaqueScopeVariables", () => {
       CodeGenState.markOpaqueScopeVariable("MyScope_widget");
-      expect(CodeGenState.isOpaqueScopeVariable("MyScope_widget")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("MyScope_widget")).toBe(
+        true,
+      );
     });
 
-    it("isOpaqueScopeVariable returns false for unknown variable", () => {
-      expect(CodeGenState.isOpaqueScopeVariable("Unknown_var")).toBe(false);
+    it("isOpaqueScopeVariableAccess returns false for unknown variable", () => {
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Unknown_var")).toBe(
+        false,
+      );
     });
 
-    it("isOpaqueScopeVariable returns true for marked variable", () => {
+    it("isOpaqueScopeVariableAccess returns true for marked variable", () => {
       CodeGenState.markOpaqueScopeVariable("Gui_display");
-      expect(CodeGenState.isOpaqueScopeVariable("Gui_display")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Gui_display")).toBe(
+        true,
+      );
     });
 
     it("reset clears opaqueScopeVariables", () => {
       CodeGenState.markOpaqueScopeVariable("Test_opaque");
-      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Test_opaque")).toBe(
+        true,
+      );
 
       CodeGenState.reset();
 
-      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(false);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Test_opaque")).toBe(
+        false,
+      );
     });
 
     it("handles multiple opaque scope variables", () => {
@@ -1037,10 +1048,241 @@ describe("CodeGenState", () => {
       CodeGenState.markOpaqueScopeVariable("Scope1_display");
       CodeGenState.markOpaqueScopeVariable("Scope2_handle");
 
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_widget")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_display")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope2_handle")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_other")).toBe(false);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_widget")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_display")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope2_handle")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_other")).toBe(
+        false,
+      );
+    });
+
+    // Issue #996: An element of an opaque-handle array is itself a pointer.
+    it("isOpaqueScopeVariableAccess matches array-element access of an opaque array", () => {
+      CodeGenState.markOpaqueScopeVariable("UI_widgets");
+
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgets[i]")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgets[0]")).toBe(
+        true,
+      );
+    });
+
+    it("isOpaqueScopeVariableAccess does not match subscript of a non-opaque array", () => {
+      // Base array name was never marked opaque.
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_counts[i]")).toBe(
+        false,
+      );
+    });
+
+    it("isOpaqueScopeVariableAccess does not match a different array that shares a prefix", () => {
+      CodeGenState.markOpaqueScopeVariable("UI_widgets");
+
+      // "UI_widgetsExtra" is a distinct variable, not a subscript of UI_widgets.
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgetsExtra")).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("withDeclarationInit()", () => {
+    it("sets inDeclarationInit to true during callback", () => {
+      CodeGenState.inDeclarationInit = false;
+      let valueInside = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        valueInside = CodeGenState.inDeclarationInit;
+      });
+
+      expect(valueInside).toBe(true);
+    });
+
+    it("restores prior value after callback", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        // inside: true
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+
+    it("restores prior value even when already true", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      CodeGenState.withDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withDeclarationInit(() => "hello");
+      expect(result).toBe("hello");
+    });
+
+    it("restores prior value on exception", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      expect(() =>
+        CodeGenState.withDeclarationInit(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+  });
+
+  describe("withoutDeclarationInit()", () => {
+    it("sets inDeclarationInit to false during callback", () => {
+      CodeGenState.inDeclarationInit = true;
+      let valueInside = true;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        valueInside = CodeGenState.inDeclarationInit;
+      });
+
+      expect(valueInside).toBe(false);
+    });
+
+    it("restores prior value after callback", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        // inside: false
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("restores prior value even when already false", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(false);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withoutDeclarationInit(() => 42);
+      expect(result).toBe(42);
+    });
+
+    it("restores prior value on exception", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      expect(() =>
+        CodeGenState.withoutDeclarationInit(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("nests correctly with withDeclarationInit", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+
+        CodeGenState.withoutDeclarationInit(() => {
+          expect(CodeGenState.inDeclarationInit).toBe(false);
+        });
+
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+  });
+
+  describe("withoutExpectedType()", () => {
+    it("clears expectedType during callback", () => {
+      CodeGenState.expectedType = "u32";
+      let typeInside: string | null = "notCleared";
+
+      CodeGenState.withoutExpectedType(() => {
+        typeInside = CodeGenState.expectedType;
+      });
+
+      expect(typeInside).toBeNull();
+    });
+
+    it("clears suppressBareEnumResolution during callback", () => {
+      CodeGenState.suppressBareEnumResolution = true;
+      let suppressInside = true;
+
+      CodeGenState.withoutExpectedType(() => {
+        suppressInside = CodeGenState.suppressBareEnumResolution;
+      });
+
+      expect(suppressInside).toBe(false);
+    });
+
+    it("restores expectedType after callback", () => {
+      CodeGenState.expectedType = "i32";
+
+      CodeGenState.withoutExpectedType(() => {
+        // inside: null
+      });
+
+      expect(CodeGenState.expectedType).toBe("i32");
+    });
+
+    it("restores suppressBareEnumResolution after callback", () => {
+      CodeGenState.suppressBareEnumResolution = true;
+
+      CodeGenState.withoutExpectedType(() => {
+        // inside: false
+      });
+
+      expect(CodeGenState.suppressBareEnumResolution).toBe(true);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withoutExpectedType(() => 123);
+      expect(result).toBe(123);
+    });
+
+    it("restores values on exception", () => {
+      CodeGenState.expectedType = "bool";
+      CodeGenState.suppressBareEnumResolution = true;
+
+      expect(() =>
+        CodeGenState.withoutExpectedType(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.expectedType).toBe("bool");
+      expect(CodeGenState.suppressBareEnumResolution).toBe(true);
+    });
+
+    it("handles null expectedType correctly", () => {
+      CodeGenState.expectedType = null;
+      CodeGenState.suppressBareEnumResolution = false;
+
+      let executed = false;
+      CodeGenState.withoutExpectedType(() => {
+        executed = true;
+        expect(CodeGenState.expectedType).toBeNull();
+        expect(CodeGenState.suppressBareEnumResolution).toBe(false);
+      });
+
+      expect(executed).toBe(true);
+      expect(CodeGenState.expectedType).toBeNull();
+      expect(CodeGenState.suppressBareEnumResolution).toBe(false);
     });
   });
 });

package/src/transpiler/types/symbols/c/ICFieldInfo.ts

@@ -9,8 +9,12 @@ interface ICFieldInfo {
   /** Field type as string (e.g., "int", "char*") */
   readonly type: string;
 
-  /** Array dimensions if this field is an array */
-  readonly arrayDimensions?: ReadonlyArray<number>;
+  /**
+   * Array dimensions if this field is an array.
+   * Issue #981: Numbers for resolved dimensions, strings for macro names.
+   * Example: [8] for numeric, ["BUF_SIZE"] for macro-sized.
+   */
+  readonly arrayDimensions?: ReadonlyArray<number | string>;
 }
 
 export default ICFieldInfo;

package/src/transpiler/types/symbols/cpp/ICppFieldInfo.ts

@@ -9,8 +9,11 @@ interface ICppFieldInfo {
   /** Field type as string (e.g., "int", "std::string") */
   readonly type: string;
 
-  /** Array dimensions if this field is an array */
-  readonly arrayDimensions?: ReadonlyArray<number>;
+  /**
+   * Array dimensions if this field is an array.
+   * Issue #981: Supports both numeric literals and macro names.
+   */
+  readonly arrayDimensions?: ReadonlyArray<number | string>;
 }
 
 export default ICppFieldInfo;

package/src/utils/LiteralUtils.ts

@@ -68,9 +68,32 @@ class LiteralUtils {
       );
     }
 
+    // Issue #1010: Float literals (0.0, 0.0f, .0, etc.)
+    if (ctx.FLOAT_LITERAL()) {
+      return LiteralUtils.isFloatZero(text);
+    }
+
     return false;
   }
 
+  /**
+   * Check if a float literal string represents zero.
+   * Issue #1010: Detect float zero for division-by-zero checking.
+   *
+   * Handles: 0.0, .0, 0., 0.0f, 0.0F, 0.0e0, 0.0E0, etc.
+   *
+   * @param text - The float literal text
+   * @returns true if the float is zero
+   */
+  static isFloatZero(text: string): boolean {
+    // Remove optional float suffix (f, F)
+    const withoutSuffix = text.replace(/[fF]$/, "");
+
+    // Parse to number and check if zero
+    const value = Number.parseFloat(withoutSuffix);
+    return value === 0;
+  }
+
   /**
    * Check if a literal is a floating-point number.
    *

package/src/utils/ScopeUtils.ts

@@ -4,6 +4,7 @@
  * Provides utilities for creating and inspecting C-Next scopes.
  */
 import type IScopeSymbol from "../transpiler/types/symbols/IScopeSymbol";
+import type TVisibility from "../transpiler/types/TVisibility";
 import ESourceLanguage from "./types/ESourceLanguage";
 
 class ScopeUtils {
@@ -79,6 +80,24 @@ class ScopeUtils {
     return scope.name === "" && scope.parent === scope;
   }
 
+  // ============================================================================
+  // Visibility Utilities
+  // ============================================================================
+
+  /**
+   * ADR-016: Get the default visibility for a scope member based on its type.
+   *
+   * Member-type-aware defaults reduce boilerplate:
+   * - Functions: public by default (API surface)
+   * - Variables/types: private by default (internal state)
+   *
+   * @param isFunction - Whether the member is a function declaration
+   * @returns The default visibility for this member type
+   */
+  static getDefaultVisibility(isFunction: boolean): TVisibility {
+    return isFunction ? "public" : "private";
+  }
+
   // ============================================================================
   // Path Utilities
   // ============================================================================

package/src/utils/__tests__/LiteralUtils.test.ts

@@ -306,6 +306,107 @@ describe("LiteralUtils", () => {
     });
   });
 
+  // ========================================================================
+  // isZero: Float Literals (Issue #1010)
+  // ========================================================================
+
+  describe("isZero - float literals (Issue #1010)", () => {
+    it("should return true for float zero (0.0)", () => {
+      const literal = extractFloatLiteral("0.0");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(true);
+    });
+
+    it("should return true for float zero with suffix (0.0f)", () => {
+      const literal = extractFloatLiteral("0.0f");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(true);
+    });
+
+    it("should return true for float zero with uppercase suffix (0.0F)", () => {
+      const literal = extractFloatLiteral("0.0F");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(true);
+    });
+
+    it("should return true for leading-dot zero (.0)", () => {
+      const literal = extractFloatLiteral(".0");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(true);
+    });
+
+    it("should return false for non-zero float (1.0)", () => {
+      const literal = extractFloatLiteral("1.0");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(false);
+    });
+
+    it("should return false for small non-zero float (0.001)", () => {
+      const literal = extractFloatLiteral("0.001");
+      expect(literal).not.toBeNull();
+      expect(LiteralUtils.isZero(literal!)).toBe(false);
+    });
+
+    it("should return false for negative float (-0.5)", () => {
+      const literal = extractFloatLiteral("-0.5");
+      // Note: -0.5 may not parse as a single literal due to negation
+      // This is expected - the unary minus is a separate operator
+      if (literal) {
+        expect(LiteralUtils.isZero(literal!)).toBe(false);
+      }
+    });
+  });
+
+  // ========================================================================
+  // isFloatZero (Issue #1010)
+  // ========================================================================
+
+  describe("isFloatZero - static method (Issue #1010)", () => {
+    it("should return true for 0.0", () => {
+      expect(LiteralUtils.isFloatZero("0.0")).toBe(true);
+    });
+
+    it("should return true for .0", () => {
+      expect(LiteralUtils.isFloatZero(".0")).toBe(true);
+    });
+
+    it("should return true for 0.", () => {
+      expect(LiteralUtils.isFloatZero("0.")).toBe(true);
+    });
+
+    it("should return true for 0.0f", () => {
+      expect(LiteralUtils.isFloatZero("0.0f")).toBe(true);
+    });
+
+    it("should return true for 0.0F", () => {
+      expect(LiteralUtils.isFloatZero("0.0F")).toBe(true);
+    });
+
+    it("should return true for scientific notation zero (0.0e0)", () => {
+      expect(LiteralUtils.isFloatZero("0.0e0")).toBe(true);
+    });
+
+    it("should return true for scientific notation zero (0e0)", () => {
+      expect(LiteralUtils.isFloatZero("0e0")).toBe(true);
+    });
+
+    it("should return false for 1.0", () => {
+      expect(LiteralUtils.isFloatZero("1.0")).toBe(false);
+    });
+
+    it("should return false for 0.5", () => {
+      expect(LiteralUtils.isFloatZero("0.5")).toBe(false);
+    });
+
+    it("should return false for 3.14", () => {
+      expect(LiteralUtils.isFloatZero("3.14")).toBe(false);
+    });
+
+    it("should return false for scientific notation non-zero (1e-10)", () => {
+      expect(LiteralUtils.isFloatZero("1e-10")).toBe(false);
+    });
+  });
+
   // ========================================================================
   // isFloat
   // ========================================================================

package/src/utils/__tests__/ScopeUtils.test.ts

@@ -50,4 +50,14 @@ describe("IScopeSymbol", () => {
       expect(ScopeUtils.isGlobalScope(scope)).toBe(false);
     });
   });
+
+  describe("getDefaultVisibility", () => {
+    it("returns 'public' for functions (API surface)", () => {
+      expect(ScopeUtils.getDefaultVisibility(true)).toBe("public");
+    });
+
+    it("returns 'private' for non-functions (internal state)", () => {
+      expect(ScopeUtils.getDefaultVisibility(false)).toBe("private");
+    });
+  });
 });

package/src/utils/types/IParameterSymbol.ts

@@ -10,6 +10,7 @@ interface IParameterSymbol {
   isAutoConst?: boolean; // Issue #268: true if parameter should get auto-const (unmodified pointer)
   isCallbackPointer?: boolean; // Issue #914: typedef says this param must be a pointer
   isCallbackConst?: boolean; // Issue #914: typedef says this param must be const
+  isOpaqueHandle?: boolean; // Issue #995: type is opaque (incomplete struct), needs pointer not reference
 }
 
 export default IParameterSymbol;