c-next 0.2.10 → 0.2.11

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.10",
+  version: "0.2.11",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -109971,6 +109971,14 @@ var SymbolTable = class {
    * These are "opaque" types that can only be used as pointers.
    */
   opaqueTypes = /* @__PURE__ */ new Set();
+  /**
+   * Issue #958: Track typedef struct type names with their source files.
+   * Maps typeName -> sourceFile. Used for scope variables which should be pointers
+   * when the struct definition comes from a different file than the typedef.
+   * If definition is in the same file as typedef, the entry is removed (value type).
+   * If definition is in a different file, the entry remains (pointer type).
+   */
+  typedefStructTypes = /* @__PURE__ */ new Map();
   /**
    * Issue #948: Track struct tag -> typedef name relationships.
    * When a typedef declares an alias for a struct tag (e.g., typedef struct _foo foo_t),
@@ -110666,6 +110674,56 @@ Rename the C-Next symbol to resolve.`
     return this.structTagAliases.get(structTag);
   }
   // ========================================================================
+  // Issue #958: Typedef Struct Type Tracking
+  // ========================================================================
+  /**
+   * Issue #958: Mark a typedef as aliasing a struct type.
+   * Records the source file to enable same-file vs cross-file distinction.
+   * @param typedefName The typedef name (e.g., "widget_t")
+   * @param sourceFile The file where the typedef was declared
+   */
+  markTypedefStructType(typedefName, sourceFile) {
+    this.typedefStructTypes.set(typedefName, sourceFile);
+  }
+  /**
+   * Issue #958: Unmark a typedef struct type when full definition is found.
+   * Only unmarks if the definition is in the SAME file as the typedef declaration.
+   * Cross-file definitions keep the typedef marked (pointer semantics).
+   * @param typeName The typedef name to unmark
+   * @param sourceFile The file where the definition was found
+   */
+  unmarkTypedefStructType(typeName, sourceFile) {
+    const typedefFile = this.typedefStructTypes.get(typeName);
+    if (typedefFile === sourceFile) {
+      this.typedefStructTypes.delete(typeName);
+    }
+  }
+  /**
+   * Issue #958: Check if a typedef aliases a struct type.
+   * Used for scope variables which should be pointers for external struct types.
+   * @param typeName The type name to check
+   * @returns true if this is a typedef'd struct type from C headers
+   */
+  isTypedefStructType(typeName) {
+    return this.typedefStructTypes.has(typeName);
+  }
+  /**
+   * Issue #958: Get all typedef struct types for cache serialization.
+   * @returns Map entries as [typeName, sourceFile] pairs
+   */
+  getAllTypedefStructTypes() {
+    return Array.from(this.typedefStructTypes.entries());
+  }
+  /**
+   * Issue #958: Restore typedef struct types from cache.
+   * @param entries Array of [typeName, sourceFile] pairs
+   */
+  restoreTypedefStructTypes(entries) {
+    for (const [name, sourceFile] of entries) {
+      this.typedefStructTypes.set(name, sourceFile);
+    }
+  }
+  // ========================================================================
   // Enum Bit Width Tracking
   // ========================================================================
   /**
@@ -110785,6 +110843,7 @@ Rename the C-Next symbol to resolve.`
     this.opaqueTypes.clear();
     this.structTagAliases.clear();
     this.enumBitWidth.clear();
+    this.typedefStructTypes.clear();
   }
 };
 var SymbolTable_default = SymbolTable;
@@ -111136,6 +111195,14 @@ var CodeGenState = class {
   static isOpaqueType(typeName) {
     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) {
+    return this.symbolTable?.isTypedefStructType(typeName) ?? false;
+  }
   /**
    * Get type info for a variable.
    * Checks local typeRegistry first, then falls back to SymbolTable
@@ -118067,7 +118134,8 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
   let type = orchestrator.generateType(varDecl.type());
   const fullName = QualifiedNameGenerator_default.forMember(scopeName, varName);
   const isOpaque = orchestrator.isOpaqueType(type);
-  if (isOpaque) {
+  const isExternalStruct = orchestrator.isTypedefStructType(type);
+  if (isOpaque || isExternalStruct) {
     type = `${type}*`;
     orchestrator.markOpaqueScopeVariable(fullName);
   }
@@ -118082,7 +118150,7 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
     decl += orchestrator.generateArrayDimensions(arrayDims);
   }
   decl += ArrayDimensionUtils_default.generateStringCapacityDim(varDecl.type());
-  if (isOpaque) {
+  if (isOpaque || isExternalStruct) {
     decl += " = NULL";
   } else {
     decl += generateInitializer(varDecl, isArray, orchestrator);
@@ -128797,6 +128865,14 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   isOpaqueType(typeName) {
     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) {
+    return CodeGenState.isTypedefStructType(typeName);
+  }
   /**
    * Issue #948: Mark a scope variable as having an opaque type.
    * These variables are generated as pointers with NULL initialization.
@@ -133680,6 +133756,18 @@ var DeclaratorUtils = class _DeclaratorUtils {
     if (!firstDeclarator) return void 0;
     return _DeclaratorUtils.extractDeclaratorName(firstDeclarator) ?? void 0;
   }
+  /**
+   * 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) {
+    const initDeclarators = initDeclList.initDeclarator?.();
+    if (!initDeclarators || initDeclarators.length === 0) return false;
+    const firstDeclarator = initDeclarators[0].declarator?.();
+    if (!firstDeclarator) return false;
+    return Boolean(firstDeclarator.pointer?.());
+  }
 };
 var DeclaratorUtils_default = DeclaratorUtils;
 
@@ -133692,11 +133780,10 @@ var StructCollector2 = class _StructCollector {
    * @param sourceFile Source file path
    * @param line Source line number
    * @param symbolTable Optional symbol table for field tracking
-   * @param typedefName Optional typedef name for anonymous structs
-   * @param isTypedef Whether this is part of a typedef declaration
-   * @param warnings Array to collect warnings
+   * @param options Optional collection options (typedef info, warnings)
    */
-  static collect(structSpec, sourceFile, line, symbolTable, typedefName, isTypedef, warnings) {
+  static collect(structSpec, sourceFile, line, symbolTable, options = {}) {
+    const { typedefName, isTypedef, warnings, isPointerTypedef } = options;
     const identifier = structSpec.Identifier();
     const name = identifier?.getText() || typedefName;
     if (!name) return null;
@@ -133710,15 +133797,14 @@ var StructCollector2 = class _StructCollector {
     );
     const needsStructKeyword = Boolean(identifier && !isTypedef);
     if (symbolTable) {
-      _StructCollector.updateSymbolTable(
-        symbolTable,
-        name,
+      _StructCollector.updateSymbolTable(symbolTable, name, sourceFile, {
         needsStructKeyword,
         hasBody,
         isTypedef,
         typedefName,
-        identifier?.getText()
-      );
+        structTag: identifier?.getText(),
+        isPointerTypedef
+      });
     }
     return {
       kind: "struct",
@@ -133736,38 +133822,54 @@ var StructCollector2 = class _StructCollector {
    * Update symbol table with struct metadata.
    * Extracted to reduce cognitive complexity of collect().
    */
-  static updateSymbolTable(symbolTable, name, needsStructKeyword, hasBody, isTypedef, typedefName, structTag) {
+  static updateSymbolTable(symbolTable, name, sourceFile, options) {
+    const {
+      needsStructKeyword,
+      hasBody,
+      isTypedef,
+      typedefName,
+      structTag,
+      isPointerTypedef
+    } = options;
     if (needsStructKeyword) {
       symbolTable.markNeedsStructKeyword(name);
     }
-    if (isTypedef && !hasBody && typedefName) {
+    if (isTypedef && !hasBody && typedefName && !isPointerTypedef) {
       symbolTable.markOpaqueType(typedefName);
       if (structTag) {
         symbolTable.registerStructTagAlias(structTag, typedefName);
       }
     }
+    if (isTypedef && typedefName && !isPointerTypedef) {
+      symbolTable.markTypedefStructType(typedefName, sourceFile);
+    }
     if (hasBody) {
       _StructCollector.unmarkOpaqueTypesOnDefinition(
         symbolTable,
+        sourceFile,
         structTag,
         typedefName
       );
     }
   }
   /**
-   * Unmark opaque types when a full struct definition is encountered.
+   * Unmark opaque and typedef struct types when a full struct definition is encountered.
    * Handles: typedef struct _foo foo; struct _foo { ... };
+   * Issue #958: Only unmarks typedefStructTypes when definition is in SAME file.
    */
-  static unmarkOpaqueTypesOnDefinition(symbolTable, structTag, typedefName) {
+  static unmarkOpaqueTypesOnDefinition(symbolTable, sourceFile, structTag, typedefName) {
     if (structTag) {
-      symbolTable.unmarkOpaqueType(structTag);
       const typedefAlias = symbolTable.getStructTagAlias(structTag);
+      symbolTable.unmarkOpaqueType(structTag);
+      symbolTable.unmarkTypedefStructType(structTag, sourceFile);
       if (typedefAlias) {
         symbolTable.unmarkOpaqueType(typedefAlias);
+        symbolTable.unmarkTypedefStructType(typedefAlias, sourceFile);
       }
     }
     if (typedefName) {
       symbolTable.unmarkOpaqueType(typedefName);
+      symbolTable.unmarkTypedefStructType(typedefName, sourceFile);
     }
   }
   /**
@@ -134154,14 +134256,18 @@ var CResolver = class _CResolver {
    */
   static collectStructSymbol(structSpec, decl, declSpecs, ctx, symbolTable, warnings) {
     const typedefName = ctx.isTypedef ? _CResolver.extractTypedefName(decl, declSpecs) : void 0;
+    const isPointerTypedef = ctx.isTypedef ? _CResolver.isPointerTypedef(decl) : false;
     const structSymbol = StructCollector_default2.collect(
       structSpec,
       ctx.sourceFile,
       ctx.line,
       symbolTable,
-      typedefName,
-      ctx.isTypedef,
-      warnings
+      {
+        typedefName,
+        isTypedef: ctx.isTypedef,
+        warnings,
+        isPointerTypedef
+      }
     );
     if (structSymbol) {
       ctx.symbols.push(structSymbol);
@@ -134179,6 +134285,16 @@ var CResolver = class _CResolver {
     }
     return DeclaratorUtils_default.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.
+   */
+  static isPointerTypedef(decl) {
+    const initDeclList = decl.initDeclaratorList();
+    if (!initDeclList) return false;
+    return DeclaratorUtils_default.firstDeclaratorHasPointer(initDeclList);
+  }
   /**
    * Collect enum symbols from an enum specifier.
    * Extracted to reduce cognitive complexity of collectDeclaration().
@@ -138880,7 +138996,7 @@ var CacheKeyGenerator_default = CacheKeyGenerator;
 
 // src/utils/cache/CacheManager.ts
 var defaultFs7 = NodeFileSystem_default.instance;
-var CACHE_VERSION = 5;
+var CACHE_VERSION = 6;
 var TRANSPILER_VERSION = package_default.version;
 var CacheManager = class {
   projectRoot;
@@ -138981,14 +139097,15 @@ var CacheManager = class {
       structFields,
       needsStructKeyword: cachedEntry.needsStructKeyword ?? [],
       enumBitWidth,
-      opaqueTypes: cachedEntry.opaqueTypes ?? []
+      opaqueTypes: cachedEntry.opaqueTypes ?? [],
+      typedefStructTypes: cachedEntry.typedefStructTypes ?? []
     };
   }
   /**
    * Store symbols and struct fields for a file
    * ADR-055 Phase 7: Takes ISerializedSymbol[] directly
    */
-  setSymbols(filePath, symbols, structFields, needsStructKeyword, enumBitWidth, opaqueTypes) {
+  setSymbols(filePath, symbols, structFields, needsStructKeyword, enumBitWidth, opaqueTypes, typedefStructTypes) {
     if (!this.cache) return;
     let cacheKey;
     try {
@@ -139017,7 +139134,8 @@ var CacheManager = class {
       structFields: serializedFields,
       needsStructKeyword,
       enumBitWidth: serializedEnumBitWidth,
-      opaqueTypes
+      opaqueTypes,
+      typedefStructTypes
     };
     this.cache.setKey(filePath, entry);
     this.dirty = true;
@@ -139046,13 +139164,15 @@ var CacheManager = class {
       symbolTable
     );
     const opaqueTypes = symbolTable.getAllOpaqueTypes();
+    const typedefStructTypes = symbolTable.getAllTypedefStructTypes();
     this.setSymbols(
       filePath,
       symbols,
       structFields,
       needsStructKeyword,
       enumBitWidth,
-      opaqueTypes
+      opaqueTypes,
+      typedefStructTypes
     );
   }
   /**
@@ -140109,6 +140229,9 @@ var Transpiler = class {
     );
     CodeGenState.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
     CodeGenState.symbolTable.restoreOpaqueTypes(cached.opaqueTypes);
+    CodeGenState.symbolTable.restoreTypedefStructTypes(
+      cached.typedefStructTypes
+    );
     this.detectCppFromFileType(file);
     return true;
   }