c-next 0.2.16 → 0.2.18

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/cache/CacheManager.ts

@@ -32,7 +32,7 @@ import ESourceLanguage from "../types/ESourceLanguage";
 const defaultFs = NodeFileSystem.instance;
 
 /** Current cache format version - increment when serialization format changes */
-const CACHE_VERSION = 7; // Issue #958: Add structTagAliases, structTagsWithBodies to cache
+const CACHE_VERSION = 8; // Issue #985: Add preprocessFailed marker to cache
 
 const TRANSPILER_VERSION = packageJson.version;
 
@@ -138,6 +138,7 @@ class CacheManager {
     typedefStructTypes: Array<[string, string]>;
     structTagAliases: Array<[string, string]>;
     structTagsWithBodies: string[];
+    preprocessFailed: boolean;
   } | null {
     if (!this.cache) return null;
 
@@ -181,6 +182,7 @@ class CacheManager {
       typedefStructTypes: cachedEntry.typedefStructTypes ?? [],
       structTagAliases: cachedEntry.structTagAliases ?? [],
       structTagsWithBodies: cachedEntry.structTagsWithBodies ?? [],
+      preprocessFailed: cachedEntry.preprocessFailed ?? false,
     };
   }
 
@@ -199,6 +201,7 @@ class CacheManager {
       typedefStructTypes?: Array<[string, string]>;
       structTagAliases?: Array<[string, string]>;
       structTagsWithBodies?: string[];
+      preprocessFailed?: boolean;
     },
   ): void {
     if (!this.cache) return;
@@ -247,6 +250,7 @@ class CacheManager {
       typedefStructTypes: options?.typedefStructTypes,
       structTagAliases: options?.structTagAliases,
       structTagsWithBodies: options?.structTagsWithBodies,
+      preprocessFailed: options?.preprocessFailed,
     };
 
     this.cache.setKey(filePath, entry);
@@ -263,8 +267,14 @@ class CacheManager {
    *
    * @param filePath - Path to the file being cached
    * @param symbolTable - SymbolTable containing all parsed symbols
+   * @param preprocessFailed - Issue #985: header fell back to raw content, so its
+   *   symbols are degraded and a warm-cache build must re-run recovery
    */
-  setSymbolsFromTable(filePath: string, symbolTable: SymbolTable): void {
+  setSymbolsFromTable(
+    filePath: string,
+    symbolTable: SymbolTable,
+    preprocessFailed = false,
+  ): void {
     // ADR-055 Phase 7: Serialize TAnySymbol directly to ISerializedSymbol
     const typedSymbols = symbolTable.getSymbolsByFile(filePath);
     const symbols = typedSymbols.map((s) => this.serializeTypedSymbol(s));
@@ -302,6 +312,7 @@ class CacheManager {
       typedefStructTypes,
       structTagAliases,
       structTagsWithBodies,
+      preprocessFailed,
     });
   }
 

package/src/utils/cache/__tests__/CacheManager.test.ts

@@ -200,6 +200,23 @@ describe("CacheManager", () => {
       });
     });
 
+    it("defaults preprocessFailed to false and round-trips it when set", async () => {
+      const cleanFile = join(testDir, "clean.h");
+      const failedFile = join(testDir, "failed.h");
+      writeFileSync(cleanFile, "// test");
+      writeFileSync(failedFile, "// test");
+
+      // Issue #985: a header that fell back to raw content records that fact so
+      // a warm-cache build re-runs external-declaration recovery.
+      cacheManager.setSymbols(cleanFile, [], new Map());
+      cacheManager.setSymbols(failedFile, [], new Map(), {
+        preprocessFailed: true,
+      });
+
+      expect(cacheManager.getSymbols(cleanFile)!.preprocessFailed).toBe(false);
+      expect(cacheManager.getSymbols(failedFile)!.preprocessFailed).toBe(true);
+    });
+
     it("should preserve optional symbol fields", async () => {
       const testFile = join(testDir, "test.h");
       writeFileSync(testFile, "// test");
@@ -1494,7 +1511,7 @@ describe("CacheManager", () => {
       const content = mockFs.getWrittenContent("/project/.cnx/config.json");
       expect(content).toBeDefined();
       const newConfig = JSON.parse(content!);
-      expect(newConfig.version).toBe(7); // Current CACHE_VERSION (Issue #958 structTagAliases, structTagsWithBodies)
+      expect(newConfig.version).toBe(8); // Current CACHE_VERSION (Issue #985 preprocessFailed marker)
     });
 
     it("should not cache files that do not exist in IFileSystem", async () => {

package/src/utils/constants/TypeConstants.ts

@@ -42,6 +42,19 @@ class TypeConstants {
    * - ArrayIndexTypeAnalyzer: detecting signed integer subscript indexes
    */
   static readonly SIGNED_TYPES: readonly string[] = ["i8", "i16", "i32", "i64"];
+
+  /**
+   * Unsigned integer types (excludes `bool`, unlike `UNSIGNED_INDEX_TYPES`).
+   *
+   * Used by:
+   * - MixedTypeCategoryAnalyzer: classifying an operand's essential type category
+   */
+  static readonly UNSIGNED_INT_TYPES: readonly string[] = [
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+  ];
 }
 
 export default TypeConstants;

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;