c-next 0.2.5 → 0.2.6

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.5",
+  version: "0.2.6",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -115165,13 +115165,17 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
     return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
   }
   let argType = orchestrator.getExpressionType(e);
+  let isPointerVariable = false;
+  const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
   if (!argType && !argCode.startsWith("&")) {
-    const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
     if (typeInfo) {
       argType = typeInfo.baseType;
     }
   }
-  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
+  if (typeInfo?.isPointer) {
+    isPointerVariable = true;
+  }
+  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && !isPointerVariable && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
   if (needsAddressOf) {
     argCode = `&${argCode}`;
   }
@@ -116861,15 +116865,18 @@ var VariableModifierBuilder = class {
    *
    * @param ctx - Parser context with modifier methods
    * @param inFunctionBody - Whether we're inside a function body (affects extern)
+   * @param hasInitializer - Whether the variable has an initializer (affects extern in C mode)
+   * @param cppMode - Whether we're generating C++ code (affects extern behavior)
    * @returns Modifier strings ready for use in generated code
    * @throws Error if both atomic and volatile are specified
    */
-  static build(ctx, inFunctionBody) {
+  static build(ctx, inFunctionBody, hasInitializer = false, cppMode = false) {
     const hasConst = ctx.constModifier?.() ?? false;
     const constMod = hasConst ? "const " : "";
     const atomicMod = ctx.atomicModifier() ? "volatile " : "";
     const volatileMod = ctx.volatileModifier() ? "volatile " : "";
-    const externMod = hasConst && !inFunctionBody ? "extern " : "";
+    const needsExtern = hasConst && !inFunctionBody && (cppMode || !hasInitializer);
+    const externMod = needsExtern ? "extern " : "";
     if (ctx.atomicModifier() && ctx.volatileModifier()) {
       const line = ctx.start?.line ?? 0;
       throw new Error(
@@ -118057,16 +118064,17 @@ var ScopeGenerator_default = generateScope;
 // src/utils/BitUtils.ts
 var BitUtils = class _BitUtils {
   /**
-   * Convert a boolean expression to an integer (0 or 1).
+   * Convert a boolean expression to an unsigned integer (0U or 1U).
    * Handles literal "true"/"false" and generates ternary for expressions.
+   * Uses unsigned literals for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param expr - The expression to convert
-   * @returns C code string representing the integer value
+   * @returns C code string representing the unsigned integer value
    */
   static boolToInt(expr) {
-    if (expr === "true") return "1";
-    if (expr === "false") return "0";
-    return `(${expr} ? 1 : 0)`;
+    if (expr === "true") return "1U";
+    if (expr === "false") return "0U";
+    return `(${expr} ? 1U : 0U)`;
   }
   /**
    * Generate a bit mask for the given width.
@@ -118123,24 +118131,26 @@ var BitUtils = class _BitUtils {
     }
   }
   /**
-   * Return the appropriate "1" literal for a given type.
-   * Uses "1ULL" for 64-bit types to avoid undefined behavior on large shifts.
+   * Return the appropriate unsigned "1" literal for a given type.
+   * Uses "1ULL" for 64-bit types, "1U" for others.
+   * MISRA C:2012 Rule 10.1 requires unsigned operands for bitwise operations.
    *
    * @param typeName - The C-Next type name (e.g., "u64", "i32")
-   * @returns "1ULL" for 64-bit types, "1" otherwise
+   * @returns "1ULL" for 64-bit types, "1U" otherwise
    */
   static oneForType(typeName) {
-    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1";
+    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1U";
   }
   /**
-   * Format a number as an uppercase hex string (e.g., 255 -> "0xFF").
+   * Format a number as an unsigned uppercase hex string (e.g., 255 -> "0xFFU").
    * Used for generating hex mask literals in generated C code.
+   * Includes U suffix for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param value - The numeric value to format
-   * @returns Hex string like "0xFF" or "0x1F"
+   * @returns Hex string like "0xFFU" or "0x1FU"
    */
   static formatHex(value) {
-    return `0x${value.toString(16).toUpperCase()}`;
+    return `0x${value.toString(16).toUpperCase()}U`;
   }
   /**
    * Generate code to read a single bit from a value.
@@ -118186,7 +118196,7 @@ var BitUtils = class _BitUtils {
   static singleBitWrite(target, offset, value, targetType) {
     const intValue = _BitUtils.boolToInt(value);
     const is64Bit = targetType === "u64" || targetType === "i64";
-    const one = is64Bit ? "1ULL" : "1";
+    const one = is64Bit ? "1ULL" : "1U";
     const valueShift = is64Bit ? `((uint64_t)${intValue} << ${offset})` : `(${intValue} << ${offset})`;
     return `${target} = (${target} & ~(${one} << ${offset})) | ${valueShift};`;
   }
@@ -120870,7 +120880,7 @@ function getBitmapFieldInfo(bitmapType, fieldName, ctx) {
 function generateBitmapWrite(target, fieldInfo, value) {
   const { maskHex } = calculateMask(fieldInfo.width);
   if (fieldInfo.width === 1) {
-    return `${target} = (${target} & ~(1 << ${fieldInfo.offset})) | (${BitUtils_default.boolToInt(value)} << ${fieldInfo.offset});`;
+    return `${target} = (${target} & ~(1U << ${fieldInfo.offset})) | (${BitUtils_default.boolToInt(value)} << ${fieldInfo.offset});`;
   } else {
     return `${target} = (${target} & ~(${maskHex} << ${fieldInfo.offset})) | ((${value} & ${maskHex}) << ${fieldInfo.offset});`;
   }
@@ -121123,9 +121133,9 @@ function handleRegisterBit(ctx) {
       bitIndex,
       true
     );
-    return `${fullName} = (1 << ${bitIndex});`;
+    return `${fullName} = (1U << ${bitIndex});`;
   }
-  return `${fullName} = (${fullName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${fullName} = (${fullName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleRegisterBitRange(ctx) {
   AssignmentHandlerUtils_default.validateNoCompoundForBitAccess(
@@ -121191,9 +121201,9 @@ function handleScopedRegisterBit(ctx) {
       bitIndex,
       true
     );
-    return `${regName} = (1 << ${bitIndex});`;
+    return `${regName} = (1U << ${bitIndex});`;
   }
-  return `${regName} = (${regName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${regName} = (${regName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleScopedRegisterBitRange(ctx) {
   AssignmentHandlerUtils_default.validateScopeContext(CodeGenState.currentScope);
@@ -121439,7 +121449,7 @@ function handleStructMemberBit(ctx) {
   validateNotCompound2(ctx);
   const target = gen6().generateAssignmentTarget(ctx.targetCtx);
   const bitIndex = gen6().generateExpression(ctx.subscripts.at(-1));
-  const one = "1";
+  const one = "1U";
   const intValue = BitUtils_default.boolToInt(ctx.generatedValue);
   return `${target} = (${target} & ~(${one} << ${bitIndex})) | (${intValue} << ${bitIndex});`;
 }
@@ -121687,9 +121697,9 @@ function handleGlobalRegisterBit(ctx) {
         `Cannot assign false to write-only register bit ${regName}[${bitIndex}]. Use the corresponding CLEAR register to clear bits.`
       );
     }
-    return `${regName} = (1 << ${bitIndex});`;
+    return `${regName} = (1U << ${bitIndex});`;
   }
-  return `${regName} = (${regName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${regName} = (${regName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleMemberChain(ctx) {
   const bitAnalysis = gen9().analyzeMemberChainForBitAccess(ctx.targetCtx);
@@ -122839,6 +122849,9 @@ var ArgumentGenerator = class _ArgumentGenerator {
     if (typeInfo?.isArray && !typeInfo.isString) {
       return id;
     }
+    if (typeInfo?.isPointer) {
+      return id;
+    }
     if (CodeGenState.currentScope) {
       const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
       if (members?.has(id)) {
@@ -124105,7 +124118,11 @@ var StringDeclHelper = class _StringDeclHelper {
       initValue,
       arrayDims
     );
-    return { code: `${decl} = ${finalInitValue};`, handled: true };
+    const suppression = "// cppcheck-suppress misra-c2012-9.3\n// cppcheck-suppress misra-c2012-9.4\n";
+    return {
+      code: `${suppression}${decl} = ${finalInitValue};`,
+      handled: true
+    };
   }
   /**
    * Handle size inference for empty array dimension.
@@ -124581,15 +124598,21 @@ ${assignments}`;
         { generateType: callbacks.generateType }
       );
     }
+    const hasInitializer = ctx.expression() !== null;
     const modifiers = VariableModifierBuilder_default.build(
       ctx,
-      CodeGenState.inFunctionBody
+      CodeGenState.inFunctionBody,
+      hasInitializer,
+      CodeGenState.cppMode
     );
     const name = ctx.IDENTIFIER().getText();
     const typeCtx = ctx.type();
     _VariableDeclHelper.validateArrayDeclarationSyntax(ctx, typeCtx, name);
     const type = callbacks.inferVariableType(ctx, name);
     callbacks.trackLocalVariable(ctx, name);
+    if (type.endsWith("*")) {
+      callbacks.markVariableAsPointer(name);
+    }
     const stringResult = StringDeclHelper_default.generateStringDecl(
       typeCtx,
       name,
@@ -129771,6 +129794,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       getExpressionType: (exprCtx) => this.getExpressionType(exprCtx),
       inferVariableType: (varCtx, name) => this._inferVariableType(varCtx, name),
       trackLocalVariable: (varCtx, name) => this._trackLocalVariable(varCtx, name),
+      markVariableAsPointer: (name) => this._markVariableAsPointer(name),
       getStringConcatOperands: (concatCtx) => this._getStringConcatOperands(concatCtx),
       getSubstringOperands: (substrCtx) => this._getSubstringOperands(substrCtx),
       getStringExprCapacity: (exprCode) => this.getStringExprCapacity(exprCode),
@@ -129779,20 +129803,116 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   }
   /**
    * Issue #696: Infer variable type, handling nullable C pointer types.
+   * Issue #895 Bug B: Infer pointer type from C function return type.
    */
   _inferVariableType(ctx, name) {
-    let type = this.generateType(ctx.type());
-    if (!name.startsWith("c_") || !ctx.expression()) {
+    const type = this.generateType(ctx.type());
+    if (!ctx.expression()) {
       return type;
     }
-    const exprText = ctx.expression().getText();
-    for (const funcName of NullCheckAnalyzer_default.getStructPointerFunctions()) {
-      if (exprText.includes(`${funcName}(`)) {
-        return `${type}*`;
+    const pointerType = this._inferPointerTypeFromFunctionCall(
+      ctx.expression(),
+      type
+    );
+    if (pointerType) {
+      return pointerType;
+    }
+    if (name.startsWith("c_")) {
+      const exprText = ctx.expression().getText();
+      for (const funcName of NullCheckAnalyzer_default.getStructPointerFunctions()) {
+        if (exprText.includes(`${funcName}(`)) {
+          return `${type}*`;
+        }
       }
     }
     return type;
   }
+  /**
+   * Issue #895 Bug B: Infer pointer type from C function return type.
+   * If initializer is a call to a C function that returns T*, and declared
+   * type is T, return T* instead of T.
+   */
+  _inferPointerTypeFromFunctionCall(expr, declaredType) {
+    const funcName = this._extractCFunctionName(expr);
+    if (!funcName) {
+      return null;
+    }
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind !== "function") {
+      return null;
+    }
+    const returnType = cFunc.type;
+    if (!returnType.endsWith("*")) {
+      return null;
+    }
+    const returnBaseType = returnType.replace(/\s*\*\s*$/, "").trim();
+    if (returnBaseType === declaredType) {
+      return `${declaredType}*`;
+    }
+    return null;
+  }
+  /**
+   * Extract C function name from expression patterns.
+   * Handles both:
+   * - global.funcName(...) - explicit global access
+   * - funcName(...) - direct call (if funcName is a known C function)
+   * Returns null if expression doesn't match these patterns.
+   */
+  _extractCFunctionName(expr) {
+    const postfix = ExpressionUnwrapper_default.getPostfixExpression(expr);
+    if (!postfix) {
+      return null;
+    }
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+    if (primary.GLOBAL()) {
+      return this._extractGlobalPatternFuncName(ops);
+    }
+    const identifier = primary.IDENTIFIER();
+    if (identifier) {
+      return this._extractDirectCallFuncName(identifier.getText(), ops);
+    }
+    return null;
+  }
+  /**
+   * Extract function name from global.funcName(...) pattern.
+   */
+  _extractGlobalPatternFuncName(ops) {
+    if (ops.length < 2) {
+      return null;
+    }
+    const memberOp = ops[0];
+    if (!memberOp.IDENTIFIER()) {
+      return null;
+    }
+    const callOp = ops[1];
+    if (!this._isCallOp(callOp)) {
+      return null;
+    }
+    return memberOp.IDENTIFIER().getText();
+  }
+  /**
+   * Extract function name from direct funcName(...) call if it's a C function.
+   */
+  _extractDirectCallFuncName(funcName, ops) {
+    if (ops.length < 1) {
+      return null;
+    }
+    if (!this._isCallOp(ops[0])) {
+      return null;
+    }
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind === "function") {
+      return funcName;
+    }
+    return null;
+  }
+  /**
+   * Check if a postfix op is a function call.
+   */
+  _isCallOp(op) {
+    return Boolean(op.argumentList() || op.getText().startsWith("("));
+  }
   /**
    * Issue #696: Track local variable for type registry and const values.
    */
@@ -129813,6 +129933,20 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       }
     }
   }
+  /**
+   * Issue #895 Bug B: Mark variable as a pointer in the type registry.
+   * Called when type inference detects that a variable should be a pointer
+   * (e.g., initialized from a C function returning T*).
+   */
+  _markVariableAsPointer(name) {
+    const typeInfo = CodeGenState.getVariableTypeInfo(name);
+    if (typeInfo) {
+      CodeGenState.setVariableTypeInfo(name, {
+        ...typeInfo,
+        isPointer: true
+      });
+    }
+  }
   // Issue #792: Methods _handleArrayDeclaration, _getArrayTypeDimension, _parseArrayTypeDimension,
   // _parseFirstArrayDimension, _validateArrayDeclarationSyntax, _extractBaseTypeName,
   // _generateVariableInitializer, _validateIntegerInitializer, _finalizeCppClassAssignments,
@@ -133389,6 +133523,8 @@ var FunctionCollector2 = class _FunctionCollector {
     const parameters = _FunctionCollector._mapParameters(
       DeclaratorUtils_default.extractFunctionParameters(declarator)
     );
+    const hasPointer = declarator.pointer() !== null;
+    const returnType = hasPointer ? `${baseType}*` : baseType;
     return {
       kind: "function",
       name,
@@ -133396,7 +133532,7 @@ var FunctionCollector2 = class _FunctionCollector {
       sourceLine: line,
       sourceLanguage: ESourceLanguage_default.C,
       isExported: !isExtern,
-      type: baseType,
+      type: returnType,
       parameters: parameters.length > 0 ? parameters : void 0,
       isDeclaration: true
     };
@@ -137085,6 +137221,8 @@ var FunctionCallAnalyzer = class {
     if (sym?.kind !== "type") return false;
     return "type" in sym && typeof sym.type === "string" && sym.type.includes("(*)");
   }
+  /** Current scope name during callback assignment scanning */
+  scanCurrentScope = null;
   /**
    * Detect functions assigned to C function pointer typedefs.
    * When `PointCallback cb <- my_handler;` is found and PointCallback
@@ -137093,12 +137231,46 @@ var FunctionCallAnalyzer = class {
   collectCallbackCompatibleFunctions(tree) {
     for (const decl of tree.declaration()) {
       const funcDecl = decl.functionDeclaration();
-      if (!funcDecl) continue;
-      const block = funcDecl.block();
-      if (!block) continue;
-      this.scanBlockForCallbackAssignments(block);
+      if (funcDecl) {
+        this.scanStandaloneFunctionForCallbacks(funcDecl);
+        continue;
+      }
+      const scopeDecl = decl.scopeDeclaration();
+      if (scopeDecl) {
+        this.scanScopeForCallbacks(scopeDecl);
+      }
     }
   }
+  /**
+   * Scan a standalone function declaration for callback assignments.
+   */
+  scanStandaloneFunctionForCallbacks(funcDecl) {
+    const block = funcDecl.block();
+    if (!block) return;
+    this.scanCurrentScope = null;
+    this.scanBlockForCallbackAssignments(block);
+  }
+  /**
+   * Scan all member functions in a scope for callback assignments (Issue #895).
+   */
+  scanScopeForCallbacks(scopeDecl) {
+    const scopeName = scopeDecl.IDENTIFIER().getText();
+    for (const member of scopeDecl.scopeMember()) {
+      this.scanScopeMemberForCallbacks(member, scopeName);
+    }
+    this.scanCurrentScope = null;
+  }
+  /**
+   * Scan a single scope member for callback assignments.
+   */
+  scanScopeMemberForCallbacks(member, scopeName) {
+    const memberFunc = member.functionDeclaration();
+    if (!memberFunc) return;
+    const block = memberFunc.block();
+    if (!block) return;
+    this.scanCurrentScope = scopeName;
+    this.scanBlockForCallbackAssignments(block);
+  }
   /**
    * Recursively scan all statements in a block for callback typedef assignments.
    */
@@ -137182,13 +137354,30 @@ var FunctionCallAnalyzer = class {
   }
   /**
    * 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.
    */
   extractFunctionReference(expr) {
     const text = expr.getText();
-    if (/^\w+(\.\w+)?$/.test(text)) {
+    const thisPattern = /^this\.(\w+)$/;
+    const thisMatch = thisPattern.exec(text);
+    if (thisMatch) {
+      if (!this.scanCurrentScope) {
+        return null;
+      }
+      return this.scanCurrentScope + "." + thisMatch[1];
+    }
+    const globalPattern = /^global\.(\w+)\.(\w+)$/;
+    const globalMatch = globalPattern.exec(text);
+    if (globalMatch) {
+      return globalMatch[1] + "." + globalMatch[2];
+    }
+    const simplePattern = /^\w+(\.\w+)?$/;
+    if (simplePattern.test(text)) {
       return text;
     }
     return null;