c-next 0.2.16 → 0.2.18

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

@@ -110,6 +110,16 @@ class SymbolTable {
    */
   private readonly needsStructKeyword: Set<string> = new Set();
 
+  /**
+   * Issue #985 recovery: names of external function-like MACROS recovered by
+   * translation-unit preprocessing (ExternalDeclarationOracle) for headers cnext
+   * could not preprocess standalone. Macros have no declaration to parse, so
+   * only their names are known; consulted by the undeclared-`global.`-call check
+   * so it does not false-positive on a real macro (e.g. FreeRTOS pdMS_TO_TICKS).
+   * Recovered FUNCTIONS are registered as full symbols (with signatures) instead.
+   */
+  private readonly externalDeclarationNames: Set<string> = new Set();
+
   /**
    * Issue #958: Immutable struct symbol state — additive only, query-time resolution.
    * Replaces separate opaqueTypes, typedefStructTypes, structTagAliases fields.
@@ -355,6 +365,21 @@ class SymbolTable {
     }
   }
 
+  /**
+   * Register external declaration names recovered via TU preprocessing.
+   * @see externalDeclarationNames
+   */
+  addExternalDeclarationNames(names: ReadonlySet<string>): void {
+    for (const name of names) {
+      this.externalDeclarationNames.add(name);
+    }
+  }
+
+  /** Whether a name was recovered as an external function / function-like macro. */
+  hasExternalDeclaration(name: string): boolean {
+    return this.externalDeclarationNames.has(name);
+  }
+
   /**
    * Get a C symbol by name (returns first match, or undefined)
    */
@@ -1016,6 +1041,26 @@ class SymbolTable {
     });
   }
 
+  /**
+   * Issue #985: Clear a struct tag's recorded body. Used by external-declaration
+   * recovery to undo a PHANTOM body — one fabricated by ANTLR error-recovery when
+   * the normal pass parsed a header's huge preprocessed blob — so a type the
+   * clean per-file re-parse proves opaque (e.g. lvgl `lv_obj_t`) resolves as
+   * opaque again (and codegen uses a pointer).
+   * @param structTag The struct tag name (e.g., "_lv_obj_t")
+   */
+  clearStructTagHasBody(structTag: string): void {
+    if (!this.structState.structTagsWithBodies.has(structTag)) return;
+    this.structState = produce(this.structState, (draft) => {
+      draft.structTagsWithBodies.delete(structTag);
+    });
+  }
+
+  /** Issue #985: The struct tag a typedef aliases, if any (e.g. lv_obj_t -> _lv_obj_t). */
+  getStructTagForTypedef(typedefName: string): string | undefined {
+    return this.structState.typedefToTag.get(typedefName);
+  }
+
   /**
    * Issue #958: Get all struct tags with bodies for cache serialization.
    * @returns Array of struct tag names
@@ -1077,12 +1122,27 @@ class SymbolTable {
    * Issue #958: Check if a typedef aliases a struct type.
    * Used for scope variables, function parameters, and local variables
    * which should be pointers for C-header struct types.
+   *
+   * Issue #948: Performs query-time resolution - if the underlying struct
+   * tag has a full body definition, this is NOT an external typedef struct
+   * (it's a complete type that can use value semantics).
+   *
    * @param typeName The type name to check
    * @returns true if this is a typedef'd struct type from C headers
    */
   isTypedefStructType(typeName: string): boolean {
-    const result = this.structState.typedefStructTypes.has(typeName);
-    return result;
+    if (!this.structState.typedefStructTypes.has(typeName)) {
+      return false;
+    }
+    // Issue #948: Query-time resolution - if the underlying struct tag
+    // has a body definition, this typedef is NOT an external struct type.
+    // Example: `typedef struct _point_t point_t;` followed by `struct _point_t { ... };`
+    // The second declaration provides the body, so point_t is a complete type.
+    const tag = this.structState.typedefToTag.get(typeName);
+    if (tag && this.structState.structTagsWithBodies.has(tag)) {
+      return false;
+    }
+    return true;
   }
 
   /**

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

@@ -772,6 +772,55 @@ describe("SymbolTable", () => {
       expect(symbolTable.isOpaqueType("handle_t")).toBe(true);
       expect(symbolTable.getAllOpaqueTypes()).toHaveLength(2);
     });
+
+    it("clearStructTagHasBody restores opacity for a phantom body (#985)", () => {
+      symbolTable.markOpaqueType("obj_t");
+      symbolTable.registerStructTagAlias("_obj", "obj_t");
+      symbolTable.markStructTagHasBody("_obj"); // phantom body from a blob parse
+      expect(symbolTable.isOpaqueType("obj_t")).toBe(false);
+
+      symbolTable.clearStructTagHasBody("_obj");
+      expect(symbolTable.isOpaqueType("obj_t")).toBe(true);
+      expect(symbolTable.getAllStructTagsWithBodies()).not.toContain("_obj");
+    });
+
+    it("clearStructTagHasBody is a no-op when the tag has no body", () => {
+      // Must not throw or spuriously mutate when the tag was never marked.
+      expect(() => symbolTable.clearStructTagHasBody("_never")).not.toThrow();
+      expect(symbolTable.getAllStructTagsWithBodies()).not.toContain("_never");
+    });
+
+    it("getStructTagForTypedef returns the aliased tag or undefined", () => {
+      symbolTable.registerStructTagAlias("_lv_obj_t", "lv_obj_t");
+      expect(symbolTable.getStructTagForTypedef("lv_obj_t")).toBe("_lv_obj_t");
+      expect(symbolTable.getStructTagForTypedef("unknown_t")).toBeUndefined();
+    });
+  });
+
+  // ========================================================================
+  // External Declaration Names (Issue #985 macro recovery)
+  // ========================================================================
+
+  describe("External Declaration Names", () => {
+    it("registers and looks up recovered function-like macro names", () => {
+      expect(symbolTable.hasExternalDeclaration("pdMS_TO_TICKS")).toBe(false);
+      symbolTable.addExternalDeclarationNames(
+        new Set(["pdMS_TO_TICKS", "portTICK_PERIOD_MS"]),
+      );
+      expect(symbolTable.hasExternalDeclaration("pdMS_TO_TICKS")).toBe(true);
+      expect(symbolTable.hasExternalDeclaration("portTICK_PERIOD_MS")).toBe(
+        true,
+      );
+      expect(symbolTable.hasExternalDeclaration("not_recovered")).toBe(false);
+    });
+
+    it("accumulates across calls and tolerates an empty set", () => {
+      symbolTable.addExternalDeclarationNames(new Set(["A"]));
+      symbolTable.addExternalDeclarationNames(new Set());
+      symbolTable.addExternalDeclarationNames(new Set(["B"]));
+      expect(symbolTable.hasExternalDeclaration("A")).toBe(true);
+      expect(symbolTable.hasExternalDeclaration("B")).toBe(true);
+    });
   });
 
   // ========================================================================
@@ -785,14 +834,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/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/output/MisraSuppressionUtils.ts

@@ -0,0 +1,52 @@
+/**
+ * MISRA Suppression Utilities
+ *
+ * Issue #850: Shared helpers for emitting MISRA inline suppression comments.
+ * Used by both CodeGenerator (for .c files) and HeaderGeneratorUtils (for .h files).
+ */
+
+/**
+ * Headers that violate MISRA C:2012 rules and need inline suppression.
+ * Maps header name to the MISRA rule it violates.
+ */
+const MISRA_BANNED_HEADERS: ReadonlyMap<string, string> = new Map([
+  // MISRA Rule 21.6: Standard library I/O functions shall not be used
+  ["stdio.h", "misra-c2012-21.6"],
+]);
+
+/**
+ * Regex to extract header name from angle-bracket includes.
+ * Uses possessive matching via atomic group simulation to avoid backtracking.
+ * Matches: #include <header.h> -> captures "header.h"
+ */
+const ANGLE_BRACKET_INCLUDE_REGEX = /<([^<>]+)>/;
+
+/**
+ * Check if an include directive needs MISRA suppression.
+ * @param includeText The full include directive (e.g., "#include <stdio.h>")
+ * @returns true if suppression is needed
+ */
+function needsMisraSuppression(includeText: string): boolean {
+  const match = ANGLE_BRACKET_INCLUDE_REGEX.exec(includeText);
+  if (!match) return false;
+  return MISRA_BANNED_HEADERS.has(match[1]);
+}
+
+/**
+ * Get the MISRA suppression comment for an include directive.
+ * @param includeText The full include directive (e.g., "#include <stdio.h>")
+ * @returns The suppression comment, or null if not needed
+ */
+function getMisraSuppressionComment(includeText: string): string | null {
+  const match = ANGLE_BRACKET_INCLUDE_REGEX.exec(includeText);
+  if (!match) return null;
+  const rule = MISRA_BANNED_HEADERS.get(match[1]);
+  return rule ? `// cppcheck-suppress ${rule}` : null;
+}
+
+const MisraSuppressionUtils = {
+  needsMisraSuppression,
+  getMisraSuppressionComment,
+};
+
+export default MisraSuppressionUtils;

package/src/transpiler/output/__tests__/MisraSuppressionUtils.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
+
+describe("MisraSuppressionUtils", () => {
+  describe("needsMisraSuppression", () => {
+    it("returns true for stdio.h", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <stdio.h>"),
+      ).toBe(true);
+    });
+
+    it("returns false for other system headers", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <stdint.h>"),
+      ).toBe(false);
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <string.h>"),
+      ).toBe(false);
+    });
+
+    it("returns false for quote includes", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression('#include "stdio.h"'),
+      ).toBe(false);
+    });
+
+    it("returns false for non-include text", () => {
+      expect(MisraSuppressionUtils.needsMisraSuppression("void foo();")).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("getMisraSuppressionComment", () => {
+    it("returns suppression comment for stdio.h", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("#include <stdio.h>"),
+      ).toBe("// cppcheck-suppress misra-c2012-21.6");
+    });
+
+    it("returns null for other system headers", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("#include <stdint.h>"),
+      ).toBeNull();
+    });
+
+    it("returns null for quote includes", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment('#include "stdio.h"'),
+      ).toBeNull();
+    });
+
+    it("returns null for non-include text", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("void foo();"),
+      ).toBeNull();
+    });
+
+    it("handles whitespace in include directives", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment(
+          "#include  <stdio.h>  ",
+        ),
+      ).toBe("// cppcheck-suppress misra-c2012-21.6");
+    });
+  });
+});