c-next 0.2.10 → 0.2.12

package/src/transpiler/logic/symbols/c/index.ts

@@ -179,14 +179,24 @@ class CResolver {
       ? CResolver.extractTypedefName(decl, declSpecs)
       : undefined;
 
+    // Issue #957: Check if the typedef's declarator has a pointer prefix.
+    // For "typedef struct X *Y", Y is already a pointer type, NOT an opaque struct.
+    // Don't mark pointer typedefs as opaque.
+    const isPointerTypedef = ctx.isTypedef
+      ? CResolver.isPointerTypedef(decl)
+      : false;
+
     const structSymbol = StructCollector.collect(
       structSpec,
       ctx.sourceFile,
       ctx.line,
       symbolTable,
-      typedefName,
-      ctx.isTypedef,
-      warnings,
+      {
+        typedefName,
+        isTypedef: ctx.isTypedef,
+        warnings,
+        isPointerTypedef,
+      },
     );
     if (structSymbol) {
       ctx.symbols.push(structSymbol);
@@ -209,6 +219,18 @@ class CResolver {
     return DeclaratorUtils.extractTypedefNameFromSpecs(declSpecs);
   }
 
+  /**
+   * Check if a typedef declaration has a pointer declarator.
+   * For "typedef struct X *Y", the declarator is "*Y" which has a pointer.
+   * Used for Issue #957 to distinguish pointer typedefs from opaque struct typedefs.
+   */
+  private static isPointerTypedef(decl: DeclarationContext): boolean {
+    const initDeclList = decl.initDeclaratorList();
+    if (!initDeclList) return false;
+
+    return DeclaratorUtils.firstDeclaratorHasPointer(initDeclList);
+  }
+
   /**
    * Collect enum symbols from an enum specifier.
    * Extracted to reduce cognitive complexity of collectDeclaration().

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

@@ -379,6 +379,23 @@ class DeclaratorUtils {
 
     return DeclaratorUtils.extractDeclaratorName(firstDeclarator) ?? undefined;
   }
+
+  /**
+   * Check if the first declarator in an init-declarator-list has a pointer.
+   * For "typedef struct X *handle_t;", the declarator is "*handle_t" which has a pointer.
+   * Used for Issue #957 to distinguish pointer typedefs from opaque struct typedefs.
+   */
+  static firstDeclaratorHasPointer(
+    initDeclList: InitDeclaratorListContext,
+  ): boolean {
+    const initDeclarators = initDeclList.initDeclarator?.();
+    if (!initDeclarators || initDeclarators.length === 0) return false;
+
+    const firstDeclarator = initDeclarators[0].declarator?.();
+    if (!firstDeclarator) return false;
+
+    return Boolean(firstDeclarator.pointer?.());
+  }
 }
 
 export default DeclaratorUtils;

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -1927,6 +1927,15 @@ export default class CodeGenerator implements IOrchestrator {
     return CodeGenState.isOpaqueType(typeName);
   }
 
+  /**
+   * Issue #958: Check if a type is an external typedef struct type.
+   * Used for scope variables which should always be pointers for external struct types.
+   * Part of IOrchestrator interface.
+   */
+  isTypedefStructType(typeName: string): boolean {
+    return CodeGenState.isTypedefStructType(typeName);
+  }
+
   /**
    * Issue #948: Mark a scope variable as having an opaque type.
    * These variables are generated as pointers with NULL initialization.
@@ -3666,6 +3675,8 @@ export default class CodeGenerator implements IOrchestrator {
       isStructType: (typeName: string) => this.isStructType(typeName),
       resolveQualifiedType: (identifiers: string[]) =>
         this.resolveQualifiedType(identifiers),
+      isTypedefStructType: (t: string) =>
+        CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
     };
   }
 
@@ -3757,6 +3768,8 @@ export default class CodeGenerator implements IOrchestrator {
       isCallbackCompatible,
       forcePassByReference,
       forceConst,
+      isTypedefStructType: (t) =>
+        CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
     });
 
     // Use shared builder with C/C++ mode
@@ -3883,6 +3896,11 @@ export default class CodeGenerator implements IOrchestrator {
   ): string {
     const type = this.generateType(ctx.type());
 
+    // Issue #958: C-header typedef struct types always need pointer semantics
+    if (CodeGenState.symbolTable?.isTypedefStructType(type)) {
+      return `${type}*`;
+    }
+
     if (!ctx.expression()) {
       return type;
     }

package/src/transpiler/output/codegen/generators/IOrchestrator.ts

@@ -399,6 +399,12 @@ interface IOrchestrator {
    */
   isOpaqueType(typeName: string): boolean;
 
+  /**
+   * Issue #958: Check if a type is an external typedef struct type.
+   * Used for scope variables which should always be pointers for external struct types.
+   */
+  isTypedefStructType(typeName: string): boolean;
+
   /**
    * Mark a scope variable as having an opaque type.
    * These variables are generated as pointers with NULL initialization.

package/src/transpiler/output/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -191,10 +191,15 @@ function generateRegularVariable(
   const fullName = QualifiedNameGenerator.forMember(scopeName, varName);
 
   // Issue #948: Check if this is an opaque (forward-declared) struct type
-  // Opaque types must be declared as pointers with NULL initialization
+  // Issue #958: Also check for external typedef struct types (complete definitions)
+  // Both opaque and external typedef struct types must be declared as pointers
   const isOpaque = orchestrator.isOpaqueType(type);
-  if (isOpaque) {
+  const isExternalStruct = orchestrator.isTypedefStructType(type);
+  if (isOpaque || isExternalStruct) {
     type = `${type}*`;
+    // Mark as "opaque" scope variable so CallExprGenerator knows this is already
+    // a pointer and doesn't add '&' when passing to functions. The name is historical
+    // but the tracking applies to any scope variable declared as a pointer type.
     orchestrator.markOpaqueScopeVariable(fullName);
   }
 
@@ -218,7 +223,8 @@ function generateRegularVariable(
   decl += ArrayDimensionUtils.generateStringCapacityDim(varDecl.type());
 
   // Issue #948: Opaque types use NULL initialization instead of {0}
-  if (isOpaque) {
+  // Issue #958: External typedef struct types also use NULL initialization
+  if (isOpaque || isExternalStruct) {
     decl += " = NULL";
   } else {
     decl += generateInitializer(varDecl, isArray, orchestrator);

package/src/transpiler/output/codegen/generators/declarationGenerators/__tests__/ScopeGenerator.test.ts

@@ -468,6 +468,8 @@ function createMockOrchestrator(
     tryEvaluateConstant: vi.fn(() => undefined),
     // Issue #948: Opaque type helpers
     isOpaqueType: vi.fn(() => false),
+    // Issue #958: Typedef struct type helper
+    isTypedefStructType: vi.fn(() => false),
     markOpaqueScopeVariable: vi.fn(),
     ...overrides,
   } as unknown as IOrchestrator;

package/src/transpiler/output/codegen/helpers/FunctionContextManager.ts

@@ -160,19 +160,27 @@ class FunctionContextManager {
     const isCallbackPointerParam =
       callbackTypedefInfo?.shouldBePointer ?? false;
 
+    // Issue #958: Check if type is a typedef'd struct from C headers
+    const isTypedefStruct =
+      callbacks.isTypedefStructType?.(typeInfo.typeName) ?? false;
+
     // Determine isStruct: for callback-compatible params, both typedef AND type info matter
     // - If typedef says pointer AND it's actually a struct, use -> access (isStruct=true)
     // - If typedef says pointer BUT it's a primitive (like u8), don't treat as struct
     //   (primitives use forcePointerSemantics for dereference instead)
+    // Issue #958: C-header typedef struct types are always treated as struct (pointer semantics)
     const isStruct = callbackTypedefInfo
       ? isCallbackPointerParam && typeInfo.isStruct
-      : typeInfo.isStruct;
+      : typeInfo.isStruct || isTypedefStruct;
 
     // Issue #895: Primitive types that become pointers need dereferencing when used as values
     // e.g., "u8 buf" becoming "uint8_t* buf" requires "*buf" when accessing the value
     const isCallbackPointerPrimitive =
       isCallbackPointerParam && !typeInfo.isStruct && !isArray;
 
+    // Issue #958: typedef struct params need pointer semantics (like callback pointer params)
+    const forcePointerSemantics = isCallbackPointerParam || isTypedefStruct;
+
     // Register in currentParameters
     const paramInfo = {
       name,
@@ -183,8 +191,8 @@ class FunctionContextManager {
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,
       isCallbackPointerPrimitive,
-      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
-      forcePointerSemantics: isCallbackPointerParam,
+      // Issue #895/#958: Force pointer semantics for callback-compatible and typedef struct params
+      forcePointerSemantics,
     };
     CodeGenState.currentParameters.set(name, paramInfo);
 
@@ -195,6 +203,7 @@ class FunctionContextManager {
       param,
       isArray,
       isConst,
+      isTypedefStruct,
     );
   }
 
@@ -320,6 +329,7 @@ class FunctionContextManager {
     param: Parser.ParameterContext,
     isArray: boolean,
     isConst: boolean,
+    isTypedefStruct = false,
   ): void {
     const { typeName, isString } = typeInfo;
     const typeCtx = param.type();
@@ -358,6 +368,8 @@ class FunctionContextManager {
       isString,
       stringCapacity,
       isParameter: true,
+      // Issue #958: typedef struct params are already pointers — prevent &arg in call sites
+      ...(isTypedefStruct && { isPointer: true }),
     };
     CodeGenState.setVariableTypeInfo(name, registeredType);
   }

package/src/transpiler/output/codegen/helpers/ParameterInputAdapter.ts

@@ -52,6 +52,9 @@ interface IFromASTDeps {
    */
   forcePassByReference?: boolean;
 
+  /** Issue #958: Check if a type name is a typedef'd struct from C headers */
+  isTypedefStructType: (typeName: string) => boolean;
+
   /**
    * Issue #895: Force const qualifier from callback typedef signature.
    * When the C typedef has `const T*`, this preserves const on the generated param.
@@ -137,15 +140,19 @@ class ParameterInputAdapter {
     // Determine classification for non-array, non-string types
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
+    // Issue #958: C-header typedef struct types need pointer semantics
+    const isTypedefStruct = deps.isTypedefStructType(typeName);
     // Issue #895: Don't add auto-const for callback-compatible functions
     // because it would change the signature and break typedef compatibility
     const isAutoConst =
       !deps.isCallbackCompatible && !deps.isModified && !isConst;
 
-    // Issue #895: For callback-compatible functions, force pass-by-reference
-    // when the typedef signature requires a pointer (e.g., opaque types)
+    // Issue #895/#958: Force pass-by-reference for callback or typedef struct types
     const isPassByReference =
-      deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
+      deps.forcePassByReference ||
+      isKnownStruct ||
+      isKnownPrimitive ||
+      isTypedefStruct;
 
     return {
       name,
@@ -158,9 +165,10 @@ class ParameterInputAdapter {
       isString: false,
       isPassByValue: deps.isPassByValue,
       isPassByReference,
-      // Issue #895: Force pointer syntax in C++ mode for callback-compatible functions
-      // because C callback typedefs expect pointers, not C++ references
-      forcePointerSyntax: deps.forcePassByReference,
+      // Issue #895/#958: Force pointer syntax in C++ mode for callback-compatible
+      // and typedef struct params (C types expect pointers, not C++ references)
+      forcePointerSyntax:
+        deps.forcePassByReference || isTypedefStruct || undefined,
       // Issue #895: Preserve const from callback typedef signature
       forceConst: deps.forceConst,
     };

package/src/transpiler/output/codegen/helpers/__tests__/ParameterInputAdapter.test.ts

@@ -62,6 +62,7 @@ function createDefaultASTDeps(overrides?: {
     isModified: overrides?.isModified ?? false,
     isPassByValue: overrides?.isPassByValue ?? false,
     isCallbackCompatible: false,
+    isTypedefStructType: () => false,
   };
 }
 

package/src/transpiler/output/codegen/types/IFunctionContextCallbacks.ts

@@ -7,6 +7,8 @@ interface IFunctionContextCallbacks {
   isStructType: (typeName: string) => boolean;
   /** Resolve qualified type identifiers to a type name */
   resolveQualifiedType: (identifiers: string[]) => string;
+  /** Issue #958: Check if a type name is a typedef'd struct from C headers */
+  isTypedefStructType?: (typeName: string) => boolean;
 }
 
 export default IFunctionContextCallbacks;

package/src/transpiler/state/CodeGenState.ts

@@ -528,6 +528,15 @@ export default class CodeGenState {
     return this.symbols?.opaqueTypes.has(typeName) ?? false;
   }
 
+  /**
+   * Issue #958: Check if a type name is an external typedef struct type.
+   * External typedef struct types should use pointer semantics for scope variables.
+   * Unlike isOpaqueType, this returns true for both forward-declared and complete structs.
+   */
+  static isTypedefStructType(typeName: string): boolean {
+    return this.symbolTable?.isTypedefStructType(typeName) ?? false;
+  }
+
   /**
    * Get type info for a variable.
    * Checks local typeRegistry first, then falls back to SymbolTable

package/src/transpiler/types/ICachedFileEntry.ts

@@ -20,6 +20,12 @@ interface ICachedFileEntry {
   enumBitWidth?: Record<string, number>;
   /** Issue #948: Opaque types (forward-declared struct types) */
   opaqueTypes?: string[];
+  /** Issue #958: Typedef struct types with source files ([typeName, sourceFile] pairs) */
+  typedefStructTypes?: Array<[string, string]>;
+  /** Issue #958: Struct tag → typedef name aliases ([structTag, typedefName] pairs) */
+  structTagAliases?: Array<[string, string]>;
+  /** Issue #958: Struct tags that have full definitions (bodies) */
+  structTagsWithBodies?: string[];
 }
 
 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 = 5; // Issue #948: Add opaqueTypes to cache
+const CACHE_VERSION = 7; // Issue #958: Add structTagAliases, structTagsWithBodies to cache
 
 const TRANSPILER_VERSION = packageJson.version;
 
@@ -135,6 +135,9 @@ class CacheManager {
     needsStructKeyword: string[];
     enumBitWidth: Map<string, number>;
     opaqueTypes: string[];
+    typedefStructTypes: Array<[string, string]>;
+    structTagAliases: Array<[string, string]>;
+    structTagsWithBodies: string[];
   } | null {
     if (!this.cache) return null;
 
@@ -175,6 +178,9 @@ class CacheManager {
       needsStructKeyword: cachedEntry.needsStructKeyword ?? [],
       enumBitWidth,
       opaqueTypes: cachedEntry.opaqueTypes ?? [],
+      typedefStructTypes: cachedEntry.typedefStructTypes ?? [],
+      structTagAliases: cachedEntry.structTagAliases ?? [],
+      structTagsWithBodies: cachedEntry.structTagsWithBodies ?? [],
     };
   }
 
@@ -186,9 +192,14 @@ class CacheManager {
     filePath: string,
     symbols: ISerializedSymbol[],
     structFields: Map<string, Map<string, IStructFieldInfo>>,
-    needsStructKeyword?: string[],
-    enumBitWidth?: Map<string, number>,
-    opaqueTypes?: string[],
+    options?: {
+      needsStructKeyword?: string[];
+      enumBitWidth?: Map<string, number>;
+      opaqueTypes?: string[];
+      typedefStructTypes?: Array<[string, string]>;
+      structTagAliases?: Array<[string, string]>;
+      structTagsWithBodies?: string[];
+    },
   ): void {
     if (!this.cache) return;
 
@@ -218,8 +229,8 @@ class CacheManager {
 
     // Issue #208: Convert enum bit widths from Map to plain object
     const serializedEnumBitWidth: Record<string, number> = {};
-    if (enumBitWidth) {
-      for (const [enumName, width] of enumBitWidth) {
+    if (options?.enumBitWidth) {
+      for (const [enumName, width] of options.enumBitWidth) {
         serializedEnumBitWidth[enumName] = width;
       }
     }
@@ -230,9 +241,12 @@ class CacheManager {
       cacheKey,
       symbols: serializedSymbols,
       structFields: serializedFields,
-      needsStructKeyword,
+      needsStructKeyword: options?.needsStructKeyword,
       enumBitWidth: serializedEnumBitWidth,
-      opaqueTypes,
+      opaqueTypes: options?.opaqueTypes,
+      typedefStructTypes: options?.typedefStructTypes,
+      structTagAliases: options?.structTagAliases,
+      structTagsWithBodies: options?.structTagsWithBodies,
     };
 
     this.cache.setKey(filePath, entry);
@@ -273,15 +287,22 @@ class CacheManager {
     // Issue #948: Extract opaque types (forward-declared structs)
     const opaqueTypes = symbolTable.getAllOpaqueTypes();
 
+    // Issue #958: Extract typedef struct types (all typedef'd structs)
+    const typedefStructTypes = symbolTable.getAllTypedefStructTypes();
+
+    // Issue #958: Extract struct tag aliases and body tracking
+    const structTagAliases = symbolTable.getAllStructTagAliases();
+    const structTagsWithBodies = symbolTable.getAllStructTagsWithBodies();
+
     // Delegate to existing setSymbols method
-    this.setSymbols(
-      filePath,
-      symbols,
-      structFields,
+    this.setSymbols(filePath, symbols, structFields, {
       needsStructKeyword,
       enumBitWidth,
       opaqueTypes,
-    );
+      typedefStructTypes,
+      structTagAliases,
+      structTagsWithBodies,
+    });
   }
 
   /**

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

@@ -361,7 +361,9 @@ describe("CacheManager", () => {
       const testFile = join(testDir, "test.h");
       writeFileSync(testFile, "// test");
 
-      cacheManager.setSymbols(testFile, [], new Map(), ["Point", "Rectangle"]);
+      cacheManager.setSymbols(testFile, [], new Map(), {
+        needsStructKeyword: ["Point", "Rectangle"],
+      });
 
       const cached = cacheManager.getSymbols(testFile);
       expect(cached!.needsStructKeyword).toEqual(["Point", "Rectangle"]);
@@ -391,7 +393,7 @@ describe("CacheManager", () => {
       enumBitWidth.set("Status", 8);
       enumBitWidth.set("Mode", 16);
 
-      cacheManager.setSymbols(testFile, [], new Map(), undefined, enumBitWidth);
+      cacheManager.setSymbols(testFile, [], new Map(), { enumBitWidth });
 
       const cached = cacheManager.getSymbols(testFile);
       expect(cached!.enumBitWidth.get("Status")).toBe(8);
@@ -405,7 +407,7 @@ describe("CacheManager", () => {
       const enumBitWidth = new Map<string, number>();
       enumBitWidth.set("Priority", 32);
 
-      cacheManager.setSymbols(testFile, [], new Map(), undefined, enumBitWidth);
+      cacheManager.setSymbols(testFile, [], new Map(), { enumBitWidth });
       await cacheManager.flush();
 
       // Reload
@@ -1492,7 +1494,7 @@ describe("CacheManager", () => {
       const content = mockFs.getWrittenContent("/project/.cnx/config.json");
       expect(content).toBeDefined();
       const newConfig = JSON.parse(content!);
-      expect(newConfig.version).toBe(5); // Current CACHE_VERSION (Issue #948 opaqueTypes)
+      expect(newConfig.version).toBe(7); // Current CACHE_VERSION (Issue #958 structTagAliases, structTagsWithBodies)
     });
 
     it("should not cache files that do not exist in IFileSystem", async () => {