c-next 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/Transpiler.ts

@@ -61,6 +61,7 @@ import CacheManager from "../utils/cache/CacheManager";
 import MapUtils from "../utils/MapUtils";
 import detectCppSyntax from "./logic/detectCppSyntax";
 import TransitiveEnumCollector from "./logic/symbols/TransitiveEnumCollector";
+import TypedefParamParser from "./output/codegen/helpers/TypedefParamParser";
 
 /**
  * Unified transpiler
@@ -680,8 +681,10 @@ class Transpiler {
       }
       const headerContent = this.generateHeaderForFile(file);
       if (headerContent) {
+        // Issue #933: Pass cppDetected to generate .hpp in C++ mode
         const headerPath = this.pathResolver.getHeaderOutputPath(
           file.discoveredFile,
+          this.cppDetected,
         );
         this.fs.writeFile(headerPath, headerContent);
         result.outputFiles.push(headerPath);
@@ -1230,7 +1233,9 @@ class Transpiler {
       return null;
     }
 
-    const headerName = basename(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
+    // Issue #933: Use .hpp extension for include guard in C++ mode
+    const ext = this.cppDetected ? ".hpp" : ".h";
+    const headerName = basename(sourcePath).replace(/\.cnx$|\.cnext$/, ext);
 
     const typeInput = this.state.getSymbolInfo(sourcePath);
     const passByValueParams =
@@ -1327,36 +1332,52 @@ class Transpiler {
     return symbols.map((symbol) => {
       const headerSymbol = HeaderSymbolAdapter.fromTSymbol(symbol);
 
-      // Apply auto-const to function parameters
       if (
-        symbol.kind === "function" &&
-        headerSymbol.parameters &&
-        headerSymbol.parameters.length > 0
+        symbol.kind !== "function" ||
+        !headerSymbol.parameters ||
+        headerSymbol.parameters.length === 0
       ) {
-        const unmodified = unmodifiedParams.get(headerSymbol.name);
-        if (unmodified) {
-          // Create a mutable copy of parameters with auto-const applied
-          const updatedParams = headerSymbol.parameters.map((param) => {
-            const isPointerParam =
-              !param.isConst &&
-              !param.isArray &&
-              param.type !== "f32" &&
-              param.type !== "f64" &&
-              param.type !== "ISR" &&
-              !knownEnums.has(param.type ?? "");
-            const isArrayParam = param.isArray && !param.isConst;
-
-            if (
-              (isPointerParam || isArrayParam) &&
-              unmodified.has(param.name)
-            ) {
-              return { ...param, isAutoConst: true };
-            }
-            return param;
-          });
-
-          return { ...headerSymbol, parameters: updatedParams };
-        }
+        return headerSymbol;
+      }
+
+      // Issue #914: Resolve callback typedef type for callback-compatible functions
+      const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+        headerSymbol.name,
+      );
+      const callbackTypedefType = typedefName
+        ? CodeGenState.getTypedefType(typedefName)
+        : undefined;
+
+      // Issue #914: For callback-compatible functions, bake pointer/const overrides
+      // onto each parameter. Skip auto-const (matches CodeGenerator path).
+      if (callbackTypedefType) {
+        const updatedParams = TypedefParamParser.resolveCallbackParams(
+          headerSymbol.parameters,
+          callbackTypedefType,
+        );
+        return { ...headerSymbol, parameters: updatedParams };
+      }
+
+      // Apply auto-const to non-callback function parameters
+      const unmodified = unmodifiedParams.get(headerSymbol.name);
+      if (unmodified) {
+        const updatedParams = headerSymbol.parameters.map((param) => {
+          const isPointerParam =
+            !param.isConst &&
+            !param.isArray &&
+            param.type !== "f32" &&
+            param.type !== "f64" &&
+            param.type !== "ISR" &&
+            !knownEnums.has(param.type ?? "");
+          const isArrayParam = param.isArray && !param.isConst;
+
+          if ((isPointerParam || isArrayParam) && unmodified.has(param.name)) {
+            return { ...param, isAutoConst: true };
+          }
+          return param;
+        });
+
+        return { ...headerSymbol, parameters: updatedParams };
       }
 
       return headerSymbol;

package/src/transpiler/__tests__/Transpiler.coverage.test.ts

@@ -556,8 +556,9 @@ describe("Transpiler coverage tests", () => {
 
       expect(result.success).toBe(true);
       // Header should be generated
+      // Issue #933: C++ mode generates .hpp extension
       const writeCalls = mockFs.getWriteLog();
-      const headerWrites = writeCalls.filter((w) => w.path.endsWith(".h"));
+      const headerWrites = writeCalls.filter((w) => w.path.endsWith(".hpp"));
       expect(headerWrites.length).toBe(1);
     });
   });

package/src/transpiler/data/PathResolver.ts

@@ -109,13 +109,17 @@ class PathResolver {
   }
 
   /**
-   * Get output path for a header file (.h)
+   * Get output path for a header file (.h or .hpp)
    * Uses headerOutDir if specified, otherwise falls back to outDir
    *
    * @param file - The discovered file to get header path for
+   * @param cppMode - If true, output .hpp; otherwise .h (Issue #933)
    * @returns The full header output path
    */
-  getHeaderOutputPath(file: IDiscoveredFile): string {
+  getHeaderOutputPath(file: IDiscoveredFile, cppMode = false): string {
+    // Issue #933: Use .hpp extension in C++ mode so C and C++ headers don't overwrite
+    const ext = cppMode ? ".hpp" : ".h";
+
     // Use headerOutDir if specified, otherwise fall back to outDir
     const headerDir = this.config.headerOutDir || this.config.outDir;
 
@@ -123,7 +127,7 @@ class PathResolver {
     if (relativePath) {
       // File is under an input directory - preserve structure (minus basePath)
       const strippedPath = this.stripBasePath(relativePath);
-      const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ".h");
+      const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ext);
       const outputPath = join(headerDir, outputRelative);
 
       const outputDir = dirname(outputPath);
@@ -142,7 +146,7 @@ class PathResolver {
       // Only use CWD-relative path if file is under CWD (not starting with ..)
       if (relativeFromCwd && !relativeFromCwd.startsWith("..")) {
         const strippedPath = this.stripBasePath(relativeFromCwd);
-        const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ".h");
+        const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ext);
         const outputPath = join(this.config.headerOutDir, outputRelative);
 
         const outputDir = dirname(outputPath);
@@ -154,7 +158,7 @@ class PathResolver {
       }
 
       // File outside CWD: put in headerOutDir with just basename
-      const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+      const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ext);
       const outputPath = join(this.config.headerOutDir, headerName);
 
       if (!this.fs.exists(this.config.headerOutDir)) {
@@ -166,7 +170,7 @@ class PathResolver {
 
     // Fallback: output next to the source file (no headerDir specified)
     // This handles included files that aren't under any input directory
-    const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+    const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ext);
     return join(dirname(file.path), headerName);
   }
 

package/src/transpiler/data/__tests__/PathResolver.test.ts

@@ -324,5 +324,37 @@ describe("PathResolver", () => {
       // src/main.cnx with basePath "src" -> main.h in headerDir
       expect(result).toBe(join(headerDir, "main.h"));
     });
+
+    // Issue #933: Test C++ mode header extension
+    it("generates .hpp path in C++ mode", () => {
+      const resolver = new PathResolver({
+        inputs: [srcDir],
+        outDir,
+      });
+
+      const filePath = join(srcDir, "main.cnx");
+      writeFileSync(filePath, "");
+      const file = createFile(filePath);
+
+      const result = resolver.getHeaderOutputPath(file, true);
+
+      expect(result).toBe(join(outDir, "main.hpp"));
+    });
+
+    it("generates .hpp path in headerOutDir in C++ mode", () => {
+      const resolver = new PathResolver({
+        inputs: [srcDir],
+        outDir,
+        headerOutDir: headerDir,
+      });
+
+      const filePath = join(srcDir, "main.cnx");
+      writeFileSync(filePath, "");
+      const file = createFile(filePath);
+
+      const result = resolver.getHeaderOutputPath(file, true);
+
+      expect(result).toBe(join(headerDir, "main.hpp"));
+    });
   });
 });

package/src/transpiler/logic/analysis/FunctionCallAnalyzer.ts

@@ -572,6 +572,9 @@ class FunctionCallAnalyzer {
     );
   }
 
+  /** Current scope name during callback assignment scanning */
+  private scanCurrentScope: string | null = null;
+
   /**
    * Detect functions assigned to C function pointer typedefs.
    * When `PointCallback cb <- my_handler;` is found and PointCallback
@@ -582,13 +585,61 @@ class FunctionCallAnalyzer {
   ): void {
     for (const decl of tree.declaration()) {
       const funcDecl = decl.functionDeclaration();
-      if (!funcDecl) continue;
+      if (funcDecl) {
+        this.scanStandaloneFunctionForCallbacks(funcDecl);
+        continue;
+      }
+
+      const scopeDecl = decl.scopeDeclaration();
+      if (scopeDecl) {
+        this.scanScopeForCallbacks(scopeDecl);
+      }
+    }
+  }
+
+  /**
+   * Scan a standalone function declaration for callback assignments.
+   */
+  private scanStandaloneFunctionForCallbacks(
+    funcDecl: Parser.FunctionDeclarationContext,
+  ): void {
+    const block = funcDecl.block();
+    if (!block) return;
+
+    this.scanCurrentScope = null;
+    this.scanBlockForCallbackAssignments(block);
+  }
 
-      const block = funcDecl.block();
-      if (!block) continue;
+  /**
+   * Scan all member functions in a scope for callback assignments (Issue #895).
+   */
+  private scanScopeForCallbacks(
+    scopeDecl: Parser.ScopeDeclarationContext,
+  ): void {
+    const scopeName = scopeDecl.IDENTIFIER().getText();
 
-      this.scanBlockForCallbackAssignments(block);
+    for (const member of scopeDecl.scopeMember()) {
+      this.scanScopeMemberForCallbacks(member, scopeName);
     }
+
+    this.scanCurrentScope = null;
+  }
+
+  /**
+   * Scan a single scope member for callback assignments.
+   */
+  private scanScopeMemberForCallbacks(
+    member: Parser.ScopeMemberContext,
+    scopeName: string,
+  ): void {
+    const memberFunc = member.functionDeclaration();
+    if (!memberFunc) return;
+
+    const block = memberFunc.block();
+    if (!block) return;
+
+    this.scanCurrentScope = scopeName;
+    this.scanBlockForCallbackAssignments(block);
   }
 
   /**
@@ -702,17 +753,41 @@ class FunctionCallAnalyzer {
 
   /**
    * Extract a function reference from an expression context.
-   * Matches bare identifiers (e.g., "my_handler") and qualified scope
-   * names (e.g., "MyScope.handler").
+   * Matches:
+   *   - Bare identifiers: "my_handler"
+   *   - Qualified scope names: "MyScope.handler"
+   *   - Self-scope reference: "this.handler" (resolved using scanCurrentScope)
+   *   - Global scope reference: "global.ScopeName.handler"
    * Returns null if the expression is not a function reference.
    */
   private extractFunctionReference(
     expr: Parser.ExpressionContext,
   ): string | null {
     const text = expr.getText();
-    if (/^\w+(\.\w+)?$/.test(text)) {
+
+    // Pattern 1: this.member -> CurrentScope.member (Issue #895)
+    const thisPattern = /^this\.(\w+)$/;
+    const thisMatch = thisPattern.exec(text);
+    if (thisMatch) {
+      if (!this.scanCurrentScope) {
+        return null; // this.member outside scope context
+      }
+      return this.scanCurrentScope + "." + thisMatch[1];
+    }
+
+    // Pattern 2: global.Scope.member -> Scope.member (Issue #895)
+    const globalPattern = /^global\.(\w+)\.(\w+)$/;
+    const globalMatch = globalPattern.exec(text);
+    if (globalMatch) {
+      return globalMatch[1] + "." + globalMatch[2];
+    }
+
+    // Pattern 3: Bare identifier or simple Scope.member
+    const simplePattern = /^\w+(\.\w+)?$/;
+    if (simplePattern.test(text)) {
       return text;
     }
+
     return null;
   }
 

package/src/transpiler/logic/analysis/PassByValueAnalyzer.ts

@@ -375,18 +375,7 @@ class PassByValueAnalyzer {
     orExpr: Parser.OrExpressionContext,
     handler: (unaryExpr: Parser.UnaryExpressionContext) => void,
   ): void {
-    orExpr
-      .andExpression()
-      .flatMap((and) => and.equalityExpression())
-      .flatMap((eq) => eq.relationalExpression())
-      .flatMap((rel) => rel.bitwiseOrExpression())
-      .flatMap((bor) => bor.bitwiseXorExpression())
-      .flatMap((bxor) => bxor.bitwiseAndExpression())
-      .flatMap((band) => band.shiftExpression())
-      .flatMap((shift) => shift.additiveExpression())
-      .flatMap((add) => add.multiplicativeExpression())
-      .flatMap((mul) => mul.unaryExpression())
-      .forEach(handler);
+    ExpressionUtils.collectUnaryFromOrExpr(orExpr).forEach(handler);
   }
 
   /**

package/src/transpiler/logic/analysis/SignedShiftAnalyzer.ts

@@ -0,0 +1,239 @@
+/**
+ * Signed Shift Analyzer
+ * Detects shift operators used with signed integer types at compile time
+ *
+ * MISRA C:2012 Rule 10.1: Operands shall not be of an inappropriate essential type
+ * - Left-shifting negative signed values is undefined behavior in C
+ * - Right-shifting negative signed values is implementation-defined in C
+ *
+ * C-Next rejects all shift operations on signed types (i8, i16, i32, i64) at
+ * compile time to ensure defined, portable behavior.
+ *
+ * Two-pass analysis:
+ * 1. Collect variable declarations with their types
+ * 2. Detect shift operations with signed operands
+ */
+
+import { ParseTreeWalker } from "antlr4ng";
+import { CNextListener } from "../parser/grammar/CNextListener";
+import * as Parser from "../parser/grammar/CNextParser";
+import ISignedShiftError from "./types/ISignedShiftError";
+import ParserUtils from "../../../utils/ParserUtils";
+import TypeConstants from "../../../utils/constants/TypeConstants";
+import ExpressionUtils from "../../../utils/ExpressionUtils";
+
+/**
+ * First pass: Collect variable declarations with their types
+ */
+class SignedVariableCollector extends CNextListener {
+  private readonly signedVars: Set<string> = new Set();
+
+  public getSignedVars(): Set<string> {
+    return this.signedVars;
+  }
+
+  /**
+   * Track a typed identifier if it has a signed type
+   */
+  private trackIfSigned(
+    typeCtx: Parser.TypeContext | null,
+    identifier: { getText(): string } | null,
+  ): void {
+    if (!typeCtx) return;
+
+    const typeName = typeCtx.getText();
+    if (!TypeConstants.SIGNED_TYPES.includes(typeName)) return;
+
+    if (!identifier) return;
+
+    this.signedVars.add(identifier.getText());
+  }
+
+  /**
+   * Track variable declarations with signed types
+   */
+  override enterVariableDeclaration = (
+    ctx: Parser.VariableDeclarationContext,
+  ): void => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+
+  /**
+   * Track function parameters with signed types
+   */
+  override enterParameter = (ctx: Parser.ParameterContext): void => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+
+  /**
+   * Track for-loop variable declarations with signed types
+   */
+  override enterForVarDecl = (ctx: Parser.ForVarDeclContext): void => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+}
+
+/**
+ * Second pass: Detect shift operations with signed operands
+ */
+class SignedShiftListener extends CNextListener {
+  private readonly analyzer: SignedShiftAnalyzer;
+
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  private readonly signedVars: Set<string>;
+
+  constructor(analyzer: SignedShiftAnalyzer, signedVars: Set<string>) {
+    super();
+    this.analyzer = analyzer;
+    this.signedVars = signedVars;
+  }
+
+  /**
+   * Check shift expressions for signed operands
+   * shiftExpression: additiveExpression (('<<' | '>>') additiveExpression)*
+   */
+  override enterShiftExpression = (
+    ctx: Parser.ShiftExpressionContext,
+  ): void => {
+    const operands = ctx.additiveExpression();
+    if (operands.length < 2) return;
+
+    // Check each operator between additive expressions
+    for (let i = 0; i < operands.length - 1; i++) {
+      const operatorToken = ctx.getChild(i * 2 + 1);
+      if (!operatorToken) continue;
+
+      const operator = operatorToken.getText();
+      if (operator !== "<<" && operator !== ">>") continue;
+
+      const leftOperand = operands[i];
+
+      // Check left operand (the value being shifted)
+      if (this.isSignedOperand(leftOperand)) {
+        const { line, column } = ParserUtils.getPosition(leftOperand);
+        this.analyzer.addError(line, column, operator);
+      }
+    }
+  };
+
+  /**
+   * Check if an additive expression contains a signed type operand
+   */
+  private isSignedOperand(ctx: Parser.AdditiveExpressionContext): boolean {
+    // Walk down to unary expressions
+    const multExprs = ctx.multiplicativeExpression();
+    for (const multExpr of multExprs) {
+      const unaryExprs = multExpr.unaryExpression();
+      for (const unaryExpr of unaryExprs) {
+        if (this.isSignedUnaryExpression(unaryExpr)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check if a unary expression is a signed type
+   */
+  private isSignedUnaryExpression(ctx: Parser.UnaryExpressionContext): boolean {
+    // Check for MINUS prefix (negation) - indicates signed context
+    // Grammar: unaryExpression: MINUS unaryExpression | ...
+    if (ctx.MINUS()) {
+      const nestedUnary = ctx.unaryExpression();
+      if (nestedUnary) {
+        // If negating a literal, it's a negative number (signed)
+        const nestedPostfix = nestedUnary.postfixExpression();
+        if (nestedPostfix) {
+          const nestedPrimary = nestedPostfix.primaryExpression();
+          if (nestedPrimary?.literal()) {
+            return true;
+          }
+        }
+        // If negating a variable, check if it's signed
+        return this.isSignedUnaryExpression(nestedUnary);
+      }
+      return false;
+    }
+
+    const postfixExpr = ctx.postfixExpression();
+    if (!postfixExpr) return false;
+
+    const primaryExpr = postfixExpr.primaryExpression();
+    if (!primaryExpr) return false;
+
+    // Check for parenthesized expression
+    const parenExpr = primaryExpr.expression();
+    if (parenExpr) {
+      return this.isSignedExpression(parenExpr);
+    }
+
+    // Check for identifier that's a signed variable
+    const identifier = primaryExpr.IDENTIFIER();
+    if (identifier) {
+      return this.signedVars.has(identifier.getText());
+    }
+
+    // Positive integer literals are treated as unsigned
+    return false;
+  }
+
+  /**
+   * Check if a full expression contains signed operands
+   */
+  private isSignedExpression(ctx: Parser.ExpressionContext): boolean {
+    const ternary = ctx.ternaryExpression();
+    if (!ternary) return false;
+
+    const additiveExprs = ExpressionUtils.collectAdditiveExpressions(ternary);
+    return additiveExprs.some((addExpr) => this.isSignedOperand(addExpr));
+  }
+}
+
+/**
+ * Analyzer that detects shift operations on signed integer types
+ */
+class SignedShiftAnalyzer {
+  private errors: ISignedShiftError[] = [];
+
+  /**
+   * Analyze the parse tree for signed shift operations
+   */
+  public analyze(tree: Parser.ProgramContext): ISignedShiftError[] {
+    this.errors = [];
+
+    // First pass: collect signed variables
+    const collector = new SignedVariableCollector();
+    ParseTreeWalker.DEFAULT.walk(collector, tree);
+    const signedVars = collector.getSignedVars();
+
+    // Second pass: detect shift with signed operands
+    const listener = new SignedShiftListener(this, signedVars);
+    ParseTreeWalker.DEFAULT.walk(listener, tree);
+
+    return this.errors;
+  }
+
+  /**
+   * Add a signed shift error
+   */
+  public addError(line: number, column: number, operator: string): void {
+    this.errors.push({
+      code: "E0805",
+      line,
+      column,
+      message: `Shift operator '${operator}' not allowed on signed integer types`,
+      helpText:
+        "Shift operations on signed integers have undefined (<<) or implementation-defined (>>) behavior. Use unsigned types (u8, u16, u32, u64) for bit manipulation.",
+    });
+  }
+
+  /**
+   * Get all detected errors
+   */
+  public getErrors(): ISignedShiftError[] {
+    return this.errors;
+  }
+}
+
+export default SignedShiftAnalyzer;