c-next 0.2.17 → 0.2.18

package/src/transpiler/output/codegen/subscript/SubscriptClassifier.ts

@@ -1,5 +1,5 @@
 /**
- * Issue #579: Shared subscript classifier for array vs bit access
+ * Issue #579 / Issue #1100: Shared subscript classifier for array vs bit access
  *
  * This utility unifies the classification logic used by:
  * - AssignmentClassifier (assignment path)
@@ -7,8 +7,28 @@
  *
  * The classification rule is:
  * 1. If isArray or isString -> array access
- * 2. If isParameter && !isArray -> array access (parameter becomes pointer in C, ADR-006)
- * 3. Otherwise -> bit manipulation
+ * 2. Otherwise -> bit manipulation
+ *
+ * This rule is identical for parameters and local variables. ADR-006 requires
+ * array parameters to use explicit array syntax (`u8[8] buf`), which sets
+ * isArray on the parameter's type info exactly like a local array declaration
+ * does. A scalar-typed parameter (no array brackets) is therefore classified
+ * the same way a scalar local variable is: bit manipulation (ADR-007 — "Any
+ * integer type can be indexed to access individual bits", with no carve-out
+ * for parameters).
+ *
+ * Issue #1100: A prior version of this classifier treated ANY function
+ * parameter without explicit array syntax as array access (`isParameter &&
+ * !isArray -> array`), added in #579 to support buffer-style parameters
+ * declared without brackets (e.g. `void fillBuffer(u8 buf)`). That blanket
+ * rule was a divergent decision path from local-variable classification: it
+ * silently broke ADR-007 bit-indexing for scalar parameters (`u32 v; ...
+ * v[4]` inside a function became `v[4]` array-subscript C code on a pointer
+ * instead of a shift-and-mask bit read), producing invalid/incorrect C
+ * for the extremely common embedded pattern of reading a bit out of a
+ * hardware-register-shaped scalar parameter. Buffer-style parameters must now
+ * use explicit array syntax (`u8[N] buf`), which was already the ADR-006
+ * documented and supported spelling — see tests/params/param-array-indexing.test.cnx.
  */
 import TSubscriptKind from "./TSubscriptKind";
 import TTypeInfo from "../types/TTypeInfo";
@@ -63,9 +83,14 @@ class SubscriptClassifier {
    * Determine if a type should use array access semantics.
    *
    * Array access is used when:
-   * - Type is explicitly an array (isArray: true)
+   * - Type is explicitly an array (isArray: true) — including array
+   *   parameters declared with explicit syntax, e.g. `u8[8] buf` (ADR-006)
    * - Type is a string (strings are char arrays)
-   * - Type is a non-array parameter (becomes pointer in C, ADR-006)
+   *
+   * Parameters are NOT special-cased here (Issue #1100): whether a subscript
+   * is array access or bit access depends solely on the declared type, the
+   * same rule used for local variables. A scalar parameter without array
+   * syntax is bit-indexable exactly like a scalar local variable (ADR-007).
    *
    * @param typeInfo - Type information, or null if unknown
    * @returns true if subscript should be treated as array access
@@ -82,12 +107,6 @@ class SubscriptClassifier {
       return true;
     }
 
-    // Issue #579: Non-array parameter becomes pointer in C (ADR-006)
-    // So buf[i] is array access, not bit access
-    if (typeInfo.isParameter) {
-      return true;
-    }
-
     // Otherwise it's a scalar - use bit access
     return false;
   }

package/src/transpiler/output/codegen/subscript/TSubscriptKind.ts

@@ -6,7 +6,7 @@
  */
 type TSubscriptKind =
   | "array_element" // Single array element access: arr[i]
-  | "array_slice" // Array slice/memcpy: arr[offset, length]
+  | "array_slice" // Array slice: arr[offset, length] (per-element little-endian writes, ADR-007/#1081)
   | "bit_single" // Single bit access: flags[3]
   | "bit_range"; // Bit range extraction: value[start, width]
 

package/src/transpiler/output/codegen/subscript/__tests__/SubscriptClassifier.test.ts

@@ -74,8 +74,13 @@ describe("SubscriptClassifier", () => {
       });
     });
 
-    describe("parameter types (Issue #579)", () => {
-      it("returns array_element for non-array parameter with single index", () => {
+    describe("parameter types (Issue #1100)", () => {
+      // A parameter's array-ness is determined solely by its declared type
+      // (isArray, from explicit `T[N]` syntax, ADR-006) — identical to local
+      // variables. `isParameter` alone must NOT force array classification;
+      // that was the Issue #579 heuristic reverted by Issue #1100 because it
+      // broke ADR-007 bit-indexing for scalar parameters.
+      it("returns bit_single for non-array parameter with single index", () => {
         const typeInfo: TTypeInfo = {
           baseType: "u8",
           bitWidth: 8,
@@ -88,10 +93,10 @@ describe("SubscriptClassifier", () => {
           subscriptCount: 1,
           isRegisterAccess: false,
         });
-        expect(result).toBe("array_element");
+        expect(result).toBe("bit_single");
       });
 
-      it("returns array_slice for non-array parameter with two indices", () => {
+      it("returns bit_range for non-array parameter with two indices", () => {
         const typeInfo: TTypeInfo = {
           baseType: "u8",
           bitWidth: 8,
@@ -104,7 +109,23 @@ describe("SubscriptClassifier", () => {
           subscriptCount: 2,
           isRegisterAccess: false,
         });
-        expect(result).toBe("array_slice");
+        expect(result).toBe("bit_range");
+      });
+
+      it("returns array_element for array parameter with single index", () => {
+        const typeInfo: TTypeInfo = {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+          isParameter: true,
+        };
+        const result = SubscriptClassifier.classify({
+          typeInfo,
+          subscriptCount: 1,
+          isRegisterAccess: false,
+        });
+        expect(result).toBe("array_element");
       });
     });
 
@@ -187,7 +208,7 @@ describe("SubscriptClassifier", () => {
       expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(true);
     });
 
-    it("returns true for parameter type", () => {
+    it("returns false for non-array parameter type (Issue #1100)", () => {
       const typeInfo: TTypeInfo = {
         baseType: "u8",
         bitWidth: 8,
@@ -195,6 +216,17 @@ describe("SubscriptClassifier", () => {
         isConst: false,
         isParameter: true,
       };
+      expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(false);
+    });
+
+    it("returns true for array parameter type", () => {
+      const typeInfo: TTypeInfo = {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: true,
+        isConst: false,
+        isParameter: true,
+      };
       expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(true);
     });
 

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -17,6 +17,7 @@ import generateStructHeader from "./generators/generateStructHeader";
 import generateBitmapHeader from "./generators/generateBitmapHeader";
 import VariableDeclarationFormatter from "../codegen/helpers/VariableDeclarationFormatter";
 import type IVariableFormatInput from "../codegen/types/IVariableFormatInput";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
 
 const { mapType, isBuiltInType } = typeUtils;
 
@@ -267,6 +268,65 @@ class HeaderGeneratorUtils {
     ];
   }
 
+  /**
+   * Extract header file stem from include directive for deduplication.
+   * E.g., '#include <foo/bar.hpp>' -> 'bar'
+   * SonarCloud S8786: Avoid backtracking by using separate patterns.
+   */
+  private static extractIncludeStem(include: string): string {
+    // Try angle brackets first, then quotes - avoids backtracking regex
+    const angleMatch = /<([^<>]+)>/.exec(include);
+    if (angleMatch) {
+      return angleMatch[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    }
+    const quoteMatch = /"([^"]+)"/.exec(include);
+    if (quoteMatch) {
+      return quoteMatch[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    }
+    return include;
+  }
+
+  /**
+   * Add user includes with MISRA suppression comments.
+   * SonarCloud S3776: Extracted from generateIncludes.
+   */
+  private static addUserIncludes(
+    lines: string[],
+    userIncludes: string[] | undefined,
+  ): void {
+    if (!userIncludes || userIncludes.length === 0) return;
+    for (const include of userIncludes) {
+      // Issue #850: Add MISRA suppression for banned headers
+      const suppression =
+        MisraSuppressionUtils.getMisraSuppressionComment(include);
+      if (suppression) {
+        lines.push(suppression);
+      }
+      lines.push(include);
+    }
+  }
+
+  /**
+   * Add external type headers, deduplicating against user includes.
+   * SonarCloud S3776: Extracted from generateIncludes.
+   */
+  private static addExternalTypeHeaders(
+    lines: string[],
+    headersToInclude: Set<string>,
+    userIncludes: string[] | undefined,
+  ): void {
+    const userIncludeSet = new Set(userIncludes ?? []);
+    const userIncludeStems = new Set(
+      (userIncludes ?? []).map(HeaderGeneratorUtils.extractIncludeStem),
+    );
+    for (const directive of headersToInclude) {
+      if (userIncludeSet.has(directive)) continue;
+      const stem = HeaderGeneratorUtils.extractIncludeStem(directive);
+      if (stem && userIncludeStems.has(stem)) continue;
+      lines.push(directive);
+    }
+  }
+
   /**
    * Generate all include directives (system, user, and external type headers)
    */
@@ -282,37 +342,18 @@ class HeaderGeneratorUtils {
     }
 
     // User includes (already have correct extension from IncludeExtractor)
-    if (options.userIncludes && options.userIncludes.length > 0) {
-      for (const include of options.userIncludes) {
-        lines.push(include);
-      }
-    }
+    HeaderGeneratorUtils.addUserIncludes(lines, options.userIncludes);
 
     // External type header includes (skip duplicates of user includes)
     // Dedup by basename stem to handle:
     // - Different path styles (e.g., <AppConfig.hpp> vs "../AppConfig.hpp")
     // - Extension mismatch from timing (.h from IncludeResolver before cppDetected,
     //   .hpp from IncludeExtractor after cppDetected)
-    const userIncludeSet = new Set(options.userIncludes ?? []);
-    const extractStem = (inc: string): string => {
-      const match = /["<]([^">]+)[">]/.exec(inc);
-      if (!match) return inc;
-      return match[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
-    };
-    const userIncludeStems = new Set(
-      (options.userIncludes ?? []).map(extractStem),
+    HeaderGeneratorUtils.addExternalTypeHeaders(
+      lines,
+      headersToInclude,
+      options.userIncludes,
     );
-    for (const directive of headersToInclude) {
-      if (userIncludeSet.has(directive)) {
-        continue;
-      }
-      // Check if a user include already covers the same file
-      const stem = extractStem(directive);
-      if (stem && userIncludeStems.has(stem)) {
-        continue;
-      }
-      lines.push(directive);
-    }
 
     // Add blank line if any includes were added
     const hasIncludes =

package/src/transpiler/state/CodeGenState.ts

@@ -30,6 +30,7 @@ import ICallbackTypeInfo from "../output/codegen/types/ICallbackTypeInfo";
 import ITargetCapabilities from "../output/codegen/types/ITargetCapabilities";
 import TOverflowBehavior from "../output/codegen/types/TOverflowBehavior";
 import TYPE_WIDTH from "../output/codegen/types/TYPE_WIDTH";
+import type ICodeGenApi from "../output/codegen/types/ICodeGenApi";
 import TypeResolver from "../../utils/TypeResolver";
 
 /**
@@ -73,10 +74,26 @@ export default class CodeGenState {
   // ===========================================================================
 
   /**
-   * Reference to the CodeGenerator instance for handlers to call methods.
-   * Typed as unknown to avoid circular dependencies - handlers cast as needed.
+   * Reference to the CodeGenerator instance for handlers to call its methods,
+   * typed to the method subset they use (ICodeGenApi). `import type` keeps this a
+   * compile-time-only edge, and CodeGenState already imports sibling types from
+   * output/codegen/types, so this introduces no runtime/circular dependency.
    */
-  static generator: unknown = null;
+  static generator: ICodeGenApi | null = null;
+
+  /**
+   * The CodeGenerator instance, asserted present. Handlers call this instead of
+   * each casting `generator` themselves — one source of truth for the access and
+   * null-check (the generator is always set before any handler runs).
+   */
+  static requireGenerator(): ICodeGenApi {
+    if (CodeGenState.generator === null) {
+      throw new Error(
+        "CodeGenState.generator is not set; codegen accessed before initialization.",
+      );
+    }
+    return CodeGenState.generator;
+  }
 
   // ===========================================================================
   // SYMBOL DATA (read-only after initialization)
@@ -142,9 +159,6 @@ export default class CodeGenState {
   /** Tracks which parameters are modified (directly or transitively) */
   static modifiedParameters: Map<string, Set<string>> = new Map();
 
-  /** Issue #579: Parameters with subscript access (must become pointers) */
-  static subscriptAccessedParameters: Map<string, Set<string>> = new Map();
-
   /** Parameters that should pass by value (small, unmodified primitives) */
   static passByValueParams: Map<string, Set<string>> = new Map();
 
@@ -363,7 +377,6 @@ export default class CodeGenState {
 
     // Pass-by-value analysis
     this.modifiedParameters = new Map();
-    this.subscriptAccessedParameters = new Map();
     this.passByValueParams = new Map();
     this.functionCallGraph = new Map();
     this.functionParamLists = new Map();
@@ -770,15 +783,6 @@ export default class CodeGenState {
     return this.passByValueParams.get(funcName)?.has(paramName) ?? false;
   }
 
-  /**
-   * Check if a parameter has subscript access.
-   */
-  static hasSubscriptAccess(funcName: string, paramName: string): boolean {
-    return (
-      this.subscriptAccessedParameters.get(funcName)?.has(paramName) ?? false
-    );
-  }
-
   /**
    * Get the function signature for a function.
    */

package/src/transpiler/types/ICachedFileEntry.ts

@@ -26,6 +26,13 @@ interface ICachedFileEntry {
   structTagAliases?: Array<[string, string]>;
   /** Issue #958: Struct tags that have full definitions (bodies) */
   structTagsWithBodies?: string[];
+  /**
+   * Issue #985: This header could not be preprocessed standalone and fell back
+   * to raw content, so its cached symbols are degraded (phantom struct bodies,
+   * missing/by-value framework signatures). Persisted so a warm-cache build
+   * still triggers the external-declaration recovery pass and re-applies the fix.
+   */
+  preprocessFailed?: boolean;
 }
 
 export default ICachedFileEntry;

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;