c-next 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -3058,9 +3058,10 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * Check if a type name is a user-defined struct
+   * Issue #322: Check if a type name is a user-defined struct
+   * Part of IOrchestrator interface.
    */
-  private isStructType(typeName: string): boolean {
+  isStructType(typeName: string): boolean {
     return this.typeResolver!.isStructType(typeName);
   }
 
@@ -7999,10 +8000,12 @@ export default class CodeGenerator implements IOrchestrator {
           currentIdentifier = memberName; // Track for .length lookups
           isGlobalAccess = true; // Mark that we're in a global access chain
           // Issue #304: Check if this is a C++ scope symbol (namespace, class, enum)
-          // Issue #314: In C++ mode, global.X.method() should always use :: syntax
-          // because the programmer is explicitly requesting C++ static method access,
-          // even for undeclared external symbols (e.g., Arduino's Serial class)
-          if (this.isCppScopeSymbol(memberName) || this.cppMode) {
+          // These require :: syntax for member access. Variable symbols (including
+          // object instances like Arduino's extern HardwareSerial Serial;) should
+          // use . syntax, not :: syntax.
+          // Issue #321: Removed || this.cppMode override - it was causing all symbols
+          // to use :: in C++ mode, even object instances that need . syntax.
+          if (this.isCppScopeSymbol(memberName)) {
             isCppAccessChain = true;
           }
           // Check if this first identifier is a register

package/src/codegen/generators/IOrchestrator.ts

@@ -72,6 +72,9 @@ interface IOrchestrator {
   /** Check if a function is defined in C-Next (vs C headers) */
   isCNextFunction(name: string): boolean;
 
+  /** Issue #322: Check if a type is a struct type */
+  isStructType(typeName: string): boolean;
+
   /** Get the raw type name without C conversion */
   getTypeName(ctx: Parser.TypeContext): string;
 

package/src/codegen/generators/expressions/CallExprGenerator.ts

@@ -147,8 +147,40 @@ const generateFunctionCall = (
       }
 
       if (!isCNextFunc) {
-        // C function: pass-by-value, just generate the expression
-        const argCode = orchestrator.generateExpression(e);
+        // C/C++ function: pass-by-value, just generate the expression
+        let argCode = orchestrator.generateExpression(e);
+
+        // Issue #322: Check if parameter expects a pointer and argument is a struct
+        // If so, automatically add & to pass the address
+        if (targetParam?.baseType?.endsWith("*")) {
+          // Try getExpressionType first
+          let argType = orchestrator.getExpressionType(e);
+
+          // Issue #322: If getExpressionType returns null (e.g., for this.member),
+          // fall back to looking up the generated code in the type registry
+          if (!argType && !argCode.startsWith("&")) {
+            // The argCode is already resolved (e.g., ConfigManager_config)
+            // Look it up directly in the type registry
+            const typeInfo = input.typeRegistry.get(argCode);
+            if (typeInfo) {
+              argType = typeInfo.baseType;
+            }
+          }
+
+          // Add & if argument is a struct type (not already a pointer)
+          // Don't add & if the expression already has & prefix
+          // Don't add & if argument is already a pointer or array
+          if (
+            argType &&
+            !argType.endsWith("*") &&
+            !argCode.startsWith("&") &&
+            !targetParam.isArray &&
+            orchestrator.isStructType(argType)
+          ) {
+            argCode = `&${argCode}`;
+          }
+        }
+
         // Issue #304: Wrap with static_cast if C++ enum class → integer
         return wrapWithCppEnumCast(
           argCode,

package/src/lib/types/ISymbolInfo.ts

@@ -1,4 +1,5 @@
 import TSymbolKind from "./TSymbolKind";
+import TLanguage from "./TLanguage";
 
 /**
  * Symbol information for IDE features (autocomplete, hover)
@@ -23,6 +24,10 @@ interface ISymbolInfo {
   line: number;
   /** Array size or bit width */
   size?: number;
+  /** Source file path where this symbol is defined */
+  sourceFile?: string;
+  /** Language of the source file */
+  language?: TLanguage;
 }
 
 export default ISymbolInfo;

package/src/lib/types/TLanguage.ts

@@ -0,0 +1,6 @@
+/**
+ * Language type for source traceability in IDE features
+ */
+type TLanguage = "cnext" | "c" | "cpp";
+
+export default TLanguage;

package/src/pipeline/Pipeline.ts

@@ -62,6 +62,8 @@ class Pipeline {
   private cppDetected: boolean;
   /** Issue #220: Store SymbolCollector per file for header generation */
   private symbolCollectors: Map<string, SymbolCollector> = new Map();
+  /** Issue #321: Track processed headers to avoid cycles during recursive include resolution */
+  private processedHeaders: Set<string> = new Set();
   /** Issue #280: Store pass-by-value params per file for header generation */
   private passByValueParamsCollectors: Map<
     string,
@@ -320,8 +322,17 @@ class Pipeline {
 
   /**
    * Stage 2: Collect symbols from C/C++ headers
+   * Issue #321: Now recursively processes #include directives to handle
+   * nested headers (e.g., Arduino's HardwareSerial.h including Stream.h)
    */
   private async collectHeaderSymbols(file: IDiscoveredFile): Promise<void> {
+    // Issue #321: Check if already processed to avoid cycles
+    const absolutePath = resolve(file.path);
+    if (this.processedHeaders.has(absolutePath)) {
+      return;
+    }
+    this.processedHeaders.add(absolutePath);
+
     // Check cache first
     if (this.cacheManager?.isValid(file.path)) {
       const cached = this.cacheManager.getSymbols(file.path);
@@ -348,35 +359,84 @@ class Pipeline {
       }
     }
 
-    let content: string;
+    // Issue #321: Read original content FIRST to extract includes before preprocessing
+    // The preprocessor expands/removes #include directives, so we need the original
+    const originalContent = readFileSync(file.path, "utf-8");
+
+    // Issue #328: Skip headers generated by C-Next Transpiler
+    // During incremental migration, generated .h files may be discovered via #include
+    // recursion from C++ files. These headers contain the same symbols as their .cnx
+    // source files, so including them would cause false symbol conflicts.
+    if (originalContent.includes("Generated by C-Next Transpiler")) {
+      if (this.config.debugMode) {
+        console.log(`[DEBUG]   Skipping C-Next generated header: ${file.path}`);
+      }
+      return;
+    }
 
-    // Preprocess if enabled
-    if (this.config.preprocess && this.preprocessor.isAvailable()) {
-      const preprocessResult = await this.preprocessor.preprocess(file.path, {
-        includePaths: this.config.includeDirs,
-        defines: this.config.defines,
-        keepLineDirectives: false,
-      });
+    // Issue #321: Recursively process #include directives in headers
+    // This ensures symbols from nested headers (like Arduino's extern HardwareSerial Serial)
+    // are properly collected even when included transitively
+    const includes = IncludeDiscovery.extractIncludes(originalContent);
+    const headerDir = dirname(absolutePath);
+    const searchPaths = [headerDir, ...this.config.includeDirs];
 
-      if (!preprocessResult.success) {
-        this.warnings.push(
-          `Preprocessor warning for ${file.path}: ${preprocessResult.error}`,
+    if (this.config.debugMode) {
+      console.log(`[DEBUG] Processing includes in ${file.path}:`);
+      console.log(`[DEBUG]   Search paths: ${searchPaths.join(", ")}`);
+    }
+
+    for (const includePath of includes) {
+      const resolved = IncludeDiscovery.resolveInclude(
+        includePath,
+        searchPaths,
+      );
+      if (this.config.debugMode) {
+        console.log(
+          `[DEBUG]   #include "${includePath}" → ${resolved || "NOT FOUND"}`,
         );
-        content = readFileSync(file.path, "utf-8");
-      } else {
-        content = preprocessResult.content;
       }
-    } else {
-      content = readFileSync(file.path, "utf-8");
+      if (resolved) {
+        const includedFile = FileDiscovery.discoverFile(resolved);
+        if (
+          includedFile &&
+          (includedFile.type === EFileType.CHeader ||
+            includedFile.type === EFileType.CppHeader)
+        ) {
+          if (this.config.debugMode) {
+            console.log(
+              `[DEBUG]     → Recursively processing ${includedFile.path}`,
+            );
+          }
+          await this.collectHeaderSymbols(includedFile);
+        }
+      }
     }
 
+    // Issue #321: Parse with ORIGINAL content, not preprocessed content
+    // The preprocessor expands includes and can lose class definitions.
+    // We need the original content to properly detect C++ syntax and parse classes.
+    // Note: Preprocessing was previously done here but is no longer needed for symbol collection.
+
     // Parse based on file type
     if (file.type === EFileType.CHeader) {
-      this.parseCHeader(content, file.path);
+      if (this.config.debugMode) {
+        console.log(`[DEBUG]   Parsing C header: ${file.path}`);
+      }
+      this.parseCHeader(originalContent, file.path);
     } else if (file.type === EFileType.CppHeader) {
       // Issue #211: .hpp files are always C++
       this.cppDetected = true;
-      this.parseCppHeader(content, file.path);
+      if (this.config.debugMode) {
+        console.log(`[DEBUG]   Parsing C++ header: ${file.path}`);
+      }
+      this.parseCppHeader(originalContent, file.path);
+    }
+
+    // Debug: Show symbols found
+    if (this.config.debugMode) {
+      const symbols = this.symbolTable.getSymbolsByFile(file.path);
+      console.log(`[DEBUG]   Found ${symbols.length} symbols in ${file.path}`);
     }
 
     // After parsing, cache the results

package/src/symbols/CppSymbolCollector.ts

@@ -102,6 +102,9 @@ class CppSymbolCollector {
       ? `${this.currentNamespace}::${name}`
       : name;
 
+    // Issue #322: Extract function parameters
+    const params = this.extractFunctionParameters(declarator);
+
     this.symbols.push({
       name: fullName,
       kind: ESymbolKind.Function,
@@ -111,6 +114,7 @@ class CppSymbolCollector {
       sourceLanguage: ESourceLanguage.Cpp,
       isExported: true,
       parent: this.currentNamespace,
+      parameters: params.length > 0 ? params : undefined,
     });
   }
 
@@ -214,6 +218,11 @@ class CppSymbolCollector {
           ? `${this.currentNamespace}::${name}`
           : name;
 
+        // Issue #322: Extract parameters for function declarations
+        const params = isFunction
+          ? this.extractFunctionParameters(declarator)
+          : [];
+
         this.symbols.push({
           name: fullName,
           kind: isFunction ? ESymbolKind.Function : ESymbolKind.Variable,
@@ -224,6 +233,7 @@ class CppSymbolCollector {
           isExported: true,
           isDeclaration: isFunction,
           parent: this.currentNamespace,
+          parameters: params.length > 0 ? params : undefined,
         });
       }
     }
@@ -280,10 +290,39 @@ class CppSymbolCollector {
    * Collect a single member declaration
    */
   private collectMemberDeclaration(className: string, memberDecl: any): void {
-    // Skip function definitions, access specifiers, etc.
-    // We only want data members
+    const line = memberDecl.start?.line ?? 0;
+
+    // Issue #322: Check for inline function definition within the class
+    const funcDef = memberDecl.functionDefinition?.();
+    if (funcDef) {
+      const declarator = funcDef.declarator?.();
+      if (declarator) {
+        const funcName = this.extractDeclaratorName(declarator);
+        if (funcName) {
+          const declSpecSeq = funcDef.declSpecifierSeq?.();
+          const returnType = declSpecSeq
+            ? this.extractTypeFromDeclSpecSeq(declSpecSeq)
+            : "void";
+          const params = this.extractFunctionParameters(declarator);
+          const fullName = `${className}::${funcName}`;
+
+          this.symbols.push({
+            name: fullName,
+            kind: ESymbolKind.Function,
+            type: returnType,
+            sourceFile: this.sourceFile,
+            sourceLine: line,
+            sourceLanguage: ESourceLanguage.Cpp,
+            isExported: true,
+            parent: className,
+            parameters: params.length > 0 ? params : undefined,
+          });
+        }
+      }
+      return;
+    }
 
-    // Get member declaration list
+    // Get member declaration list (for data members and function declarations)
     const declSpecSeq = memberDecl.declSpecifierSeq?.();
     if (!declSpecSeq) return;
 
@@ -300,8 +339,23 @@ class CppSymbolCollector {
       const fieldName = this.extractDeclaratorName(declarator);
       if (!fieldName) continue;
 
-      // Check if this is a function (has parameters) - skip functions
+      // Issue #322: Collect member functions with their parameters
       if (this.declaratorIsFunction(declarator)) {
+        const params = this.extractFunctionParameters(declarator);
+        const fullName = `${className}::${fieldName}`;
+
+        this.symbols.push({
+          name: fullName,
+          kind: ESymbolKind.Function,
+          type: fieldType,
+          sourceFile: this.sourceFile,
+          sourceLine: line,
+          sourceLanguage: ESourceLanguage.Cpp,
+          isExported: true,
+          isDeclaration: true,
+          parent: className,
+          parameters: params.length > 0 ? params : undefined,
+        });
         continue;
       }
 
@@ -508,6 +562,166 @@ class CppSymbolCollector {
     return false;
   }
 
+  /**
+   * Issue #322: Extract function parameters from a declarator.
+   * Returns an array of parameter info objects with name, type, and pointer flag.
+   */
+  private extractFunctionParameters(declarator: any): Array<{
+    name: string;
+    type: string;
+    isConst: boolean;
+    isArray: boolean;
+  }> {
+    const params: Array<{
+      name: string;
+      type: string;
+      isConst: boolean;
+      isArray: boolean;
+    }> = [];
+
+    // Find parametersAndQualifiers from the declarator
+    let paramsAndQuals: any = null;
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      paramsAndQuals = noPtr?.parametersAndQualifiers?.();
+    }
+    if (!paramsAndQuals) {
+      const noPtr = declarator.noPointerDeclarator?.();
+      paramsAndQuals = noPtr?.parametersAndQualifiers?.();
+    }
+    if (!paramsAndQuals) {
+      return params;
+    }
+
+    // Get parameterDeclarationClause
+    const paramClause = paramsAndQuals.parameterDeclarationClause?.();
+    if (!paramClause) {
+      return params;
+    }
+
+    // Get parameterDeclarationList
+    const paramList = paramClause.parameterDeclarationList?.();
+    if (!paramList) {
+      return params;
+    }
+
+    // Iterate over parameterDeclaration entries
+    for (const paramDecl of paramList.parameterDeclaration?.() ?? []) {
+      const paramInfo = this.extractParameterInfo(paramDecl);
+      if (paramInfo) {
+        params.push(paramInfo);
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Issue #322: Extract type and name info from a single parameter declaration.
+   */
+  private extractParameterInfo(paramDecl: any): {
+    name: string;
+    type: string;
+    isConst: boolean;
+    isArray: boolean;
+  } | null {
+    // Get the type from declSpecifierSeq
+    const declSpecSeq = paramDecl.declSpecifierSeq?.();
+    if (!declSpecSeq) {
+      return null;
+    }
+
+    let baseType = this.extractTypeFromDeclSpecSeq(declSpecSeq);
+    let isConst = false;
+    let isPointer = false;
+
+    // Check for const qualifier
+    const declText = declSpecSeq.getText();
+    if (declText.includes("const")) {
+      isConst = true;
+    }
+
+    // Check for pointer in declarator or abstractDeclarator
+    const declarator = paramDecl.declarator?.();
+    const abstractDecl = paramDecl.abstractDeclarator?.();
+
+    if (declarator) {
+      // Check if declarator has pointer operator
+      if (this.declaratorHasPointer(declarator)) {
+        isPointer = true;
+      }
+    }
+    if (abstractDecl) {
+      // Abstract declarator (no name) - check for pointer
+      if (this.abstractDeclaratorHasPointer(abstractDecl)) {
+        isPointer = true;
+      }
+    }
+
+    // If pointer, append * to the type
+    if (isPointer) {
+      baseType = baseType + "*";
+    }
+
+    // Get parameter name (may be empty for abstract declarators)
+    let paramName = "";
+    if (declarator) {
+      const name = this.extractDeclaratorName(declarator);
+      if (name) {
+        paramName = name;
+      }
+    }
+
+    return {
+      name: paramName,
+      type: baseType,
+      isConst,
+      isArray: false, // Could be enhanced to detect arrays
+    };
+  }
+
+  /**
+   * Issue #322: Check if a declarator contains a pointer operator.
+   */
+  private declaratorHasPointer(declarator: any): boolean {
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      // Check for pointerOperator children
+      const ptrOps = ptrDecl.pointerOperator?.();
+      if (ptrOps && ptrOps.length > 0) {
+        return true;
+      }
+      // Also check getText for *
+      if (ptrDecl.getText().includes("*")) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Issue #322: Check if an abstract declarator (pointer without name) contains a pointer.
+   */
+  private abstractDeclaratorHasPointer(abstractDecl: any): boolean {
+    // Check for pointerAbstractDeclarator
+    const ptrAbstract = abstractDecl.pointerAbstractDeclarator?.();
+    if (ptrAbstract) {
+      const ptrOps = ptrAbstract.pointerOperator?.();
+      if (ptrOps && ptrOps.length > 0) {
+        return true;
+      }
+      if (ptrAbstract.getText().includes("*")) {
+        return true;
+      }
+    }
+    // Simple check for * in the text
+    if (abstractDecl.getText().includes("*")) {
+      return true;
+    }
+    return false;
+  }
+
   private extractTypeFromDeclSpecSeq(declSpecSeq: any): string {
     const parts: string[] = [];