c-next 0.2.3 → 0.2.5

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -110,6 +110,8 @@ const initializeTrackingState = (
 interface IPostfixContext {
   rootIdentifier: string | undefined;
   isStructParam: boolean;
+  /** Issue #895: Force pointer semantics for callback-compatible params */
+  forcePointerSemantics: boolean;
   input: IGeneratorInput;
   state: IGeneratorState;
   orchestrator: IOrchestrator;
@@ -149,6 +151,8 @@ const generatePostfixExpression = (
     ? state.currentParameters.get(rootIdentifier)
     : null;
   const isStructParam = paramInfo?.isStruct ?? false;
+  // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+  const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
 
   // Issue #579: Check if we have subscript access on a non-array parameter
   const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
@@ -178,6 +182,7 @@ const generatePostfixExpression = (
   const postfixCtx: IPostfixContext = {
     rootIdentifier,
     isStructParam,
+    forcePointerSemantics,
     input,
     state,
     orchestrator,
@@ -303,6 +308,7 @@ const handleMemberOp = (
       memberName,
       rootIdentifier: ctx.rootIdentifier,
       isStructParam: ctx.isStructParam,
+      forcePointerSemantics: ctx.forcePointerSemantics,
       isGlobalAccess: tracking.isGlobalAccess,
       isCppAccessChain: tracking.isCppAccessChain,
       currentStructType: tracking.currentStructType,
@@ -1409,6 +1415,8 @@ interface IMemberAccessContext {
   memberName: string;
   rootIdentifier: string | undefined;
   isStructParam: boolean;
+  /** Issue #895: Force pointer semantics for callback-compatible params */
+  forcePointerSemantics: boolean;
   isGlobalAccess: boolean;
   isCppAccessChain: boolean;
   currentStructType: string | undefined;
@@ -1657,9 +1665,13 @@ const tryStructParamAccess = (
     return null;
   }
 
-  const structParamSep = memberAccessChain.getStructParamSeparator({
-    cppMode: orchestrator.isCppMode(),
-  });
+  // Issue #895: Force pointer semantics for callback-compatible params
+  // even in C++ mode (use -> instead of .)
+  const structParamSep = ctx.forcePointerSemantics
+    ? "->"
+    : memberAccessChain.getStructParamSeparator({
+        cppMode: orchestrator.isCppMode(),
+      });
 
   const output = initializeMemberOutput(ctx);
   output.result = `${ctx.result}${structParamSep}${ctx.memberName}`;

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -200,7 +200,7 @@ function createMockOrchestrator(overrides?: {
     indent: vi.fn((text) => text),
     validateNoEarlyExits: vi.fn(),
     validateSwitchStatement: vi.fn(),
-    validateDoWhileCondition: vi.fn(),
+    validateConditionIsBoolean: vi.fn(),
     validateConditionNoFunctionCall: vi.fn(),
     validateTernaryConditionNoFunctionCall: vi.fn(),
     generateAssignmentTarget: vi.fn(),

package/src/transpiler/output/codegen/generators/statements/ControlFlowGenerator.ts

@@ -118,6 +118,9 @@ const generateIf = (
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "if");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "if");
+
   // Generate with cache enabled
   const condition = orchestrator.generateExpression(node.expression());
 
@@ -161,6 +164,9 @@ const generateWhile = (
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "while");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "while");
+
   const condition = orchestrator.generateExpression(node.expression());
 
   // Issue #250: Flush any temp vars from condition BEFORE generating body
@@ -189,12 +195,12 @@ const generateDoWhile = (
 ): IGeneratorOutput => {
   const effects: TGeneratorEffect[] = [];
 
-  // Validate the condition is a boolean expression (E0701)
-  orchestrator.validateDoWhileCondition(node.expression());
-
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "do-while");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "do-while");
+
   const body = orchestrator.generateBlock(node.block());
   const condition = orchestrator.generateExpression(node.expression());
 
@@ -311,6 +317,9 @@ const generateFor = (
   if (node.expression()) {
     // Issue #254: Validate no function calls in condition (E0702)
     orchestrator.validateConditionNoFunctionCall(node.expression()!, "for");
+
+    // Issue #884: Validate condition is a boolean expression (E0701)
+    orchestrator.validateConditionIsBoolean(node.expression()!, "for");
     condition = orchestrator.generateExpression(node.expression()!);
   }
 

package/src/transpiler/output/codegen/generators/statements/__tests__/ControlFlowGenerator.test.ts

@@ -364,7 +364,7 @@ function createMockOrchestrator(options?: {
     registerLocalVariable: vi.fn(),
     flushPendingTempDeclarations: vi.fn(() => options?.tempDeclarations ?? ""),
     validateConditionNoFunctionCall: vi.fn(),
-    validateDoWhileCondition: vi.fn(),
+    validateConditionIsBoolean: vi.fn(),
     countStringLengthAccesses: vi.fn(() => new Map()),
     countBlockLengthAccesses: vi.fn(),
     setupLengthCache: vi.fn(() => options?.lengthCacheDecls ?? ""),
@@ -690,15 +690,15 @@ describe("ControlFlowGenerator", () => {
       const ctx = createMockDoWhileStatement({ expr });
       const input = createMockInput();
       const state = createMockState();
-      const validateDoWhileCondition = vi.fn();
+      const validateConditionIsBoolean = vi.fn();
       const orchestrator = {
         ...createMockOrchestrator(),
-        validateDoWhileCondition,
+        validateConditionIsBoolean,
       } as unknown as IOrchestrator;
 
       generateDoWhile(ctx, input, state, orchestrator);
 
-      expect(validateDoWhileCondition).toHaveBeenCalledWith(expr);
+      expect(validateConditionIsBoolean).toHaveBeenCalledWith(expr, "do-while");
     });
 
     it("validates no function calls in condition (Issue #254)", () => {

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

@@ -15,6 +15,8 @@ import CodeGenState from "../../../state/CodeGenState.js";
 import TYPE_WIDTH from "../types/TYPE_WIDTH.js";
 import ArrayDimensionParser from "./ArrayDimensionParser.js";
 import IFunctionContextCallbacks from "../types/IFunctionContextCallbacks.js";
+// Issue #895: Parse typedef signatures to determine pointer vs value params
+import TypedefParamParser from "./TypedefParamParser.js";
 
 /**
  * Result from resolving parameter type information.
@@ -124,8 +126,9 @@ class FunctionContextManager {
     CodeGenState.currentParameters.clear();
     if (!params) return;
 
-    for (const param of params.parameter()) {
-      FunctionContextManager.processParameter(param, callbacks);
+    const paramList = params.parameter();
+    for (let i = 0; i < paramList.length; i++) {
+      FunctionContextManager.processParameter(paramList[i], callbacks, i);
     }
   }
 
@@ -135,6 +138,7 @@ class FunctionContextManager {
   static processParameter(
     param: Parser.ParameterContext,
     callbacks: IFunctionContextCallbacks,
+    paramIndex: number,
   ): void {
     const name = param.IDENTIFIER().getText();
     // Check both C-Next style (u8[8] param) and legacy style (u8 param[8])
@@ -149,15 +153,38 @@ class FunctionContextManager {
       callbacks,
     );
 
+    // Issue #895: For callback-compatible functions, check the typedef signature
+    // to determine if the param should be a pointer or value
+    const callbackTypedefInfo =
+      FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isCallbackPointerParam =
+      callbackTypedefInfo?.shouldBePointer ?? 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)
+    const isStruct = callbackTypedefInfo
+      ? isCallbackPointerParam && typeInfo.isStruct
+      : typeInfo.isStruct;
+
+    // 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;
+
     // Register in currentParameters
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: typeInfo.isStruct,
+      isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,
+      isCallbackPointerPrimitive,
+      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+      forcePointerSemantics: isCallbackPointerParam,
     };
     CodeGenState.currentParameters.set(name, paramInfo);
 
@@ -366,6 +393,40 @@ class FunctionContextManager {
     return dimensions;
   }
 
+  /**
+   * Issue #895: Get callback typedef parameter info from the C header.
+   * Returns null if not callback-compatible or index is invalid.
+   */
+  static getCallbackTypedefParamInfo(
+    paramIndex: number,
+  ): { shouldBePointer: boolean; shouldBeConst: boolean } | null {
+    if (CodeGenState.currentFunctionName === null) return null;
+
+    const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+      CodeGenState.currentFunctionName,
+    );
+    if (!typedefName) return null;
+
+    const typedefType = CodeGenState.getTypedefType(typedefName);
+    if (!typedefType) return null;
+
+    const shouldBePointer = TypedefParamParser.shouldBePointer(
+      typedefType,
+      paramIndex,
+    );
+    const shouldBeConst = TypedefParamParser.shouldBeConst(
+      typedefType,
+      paramIndex,
+    );
+
+    if (shouldBePointer === null) return null;
+
+    return {
+      shouldBePointer,
+      shouldBeConst: shouldBeConst ?? false,
+    };
+  }
+
   /**
    * Extract string capacity from a string type context.
    */

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

@@ -15,6 +15,19 @@
 import ISeparatorContext from "../types/ISeparatorContext";
 import IMemberSeparatorDeps from "../types/IMemberSeparatorDeps";
 
+/**
+ * Input parameters for building a separator context
+ */
+interface IBuildContextInput {
+  firstId: string;
+  hasGlobal: boolean;
+  hasThis: boolean;
+  currentScope: string | null;
+  isStructParam: boolean;
+  isCppAccess: boolean;
+  forcePointerSemantics?: boolean;
+}
+
 /**
  * Static utility for resolving member access separators
  */
@@ -23,14 +36,18 @@ class MemberSeparatorResolver {
    * Build the separator context for a member access chain
    */
   static buildContext(
-    firstId: string,
-    hasGlobal: boolean,
-    hasThis: boolean,
-    currentScope: string | null,
-    isStructParam: boolean,
+    input: IBuildContextInput,
     deps: IMemberSeparatorDeps,
-    isCppAccess: boolean,
   ): ISeparatorContext {
+    const {
+      firstId,
+      hasGlobal,
+      hasThis,
+      currentScope,
+      isStructParam,
+      isCppAccess,
+      forcePointerSemantics,
+    } = input;
     const isCrossScope =
       hasGlobal &&
       (deps.isKnownScope(firstId) || deps.isKnownRegister(firstId));
@@ -48,6 +65,7 @@ class MemberSeparatorResolver {
       isCppAccess,
       scopedRegName,
       isScopedRegister,
+      forcePointerSemantics,
     };
   }
 
@@ -66,7 +84,11 @@ class MemberSeparatorResolver {
     }
 
     // Struct parameter uses -> in C mode, . in C++ mode
+    // Issue #895: forcePointerSemantics overrides C++ mode to use ->
     if (ctx.isStructParam) {
+      if (ctx.forcePointerSemantics) {
+        return "->";
+      }
       return deps.getStructParamSeparator();
     }
 

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

@@ -28,6 +28,12 @@ class ParameterDereferenceResolver {
     paramInfo: TParameterInfo,
     deps: IParameterDereferenceDeps,
   ): boolean {
+    // Issue #895: Primitive params that became pointers due to callback typedef
+    // are NOT pass-by-value - they need dereferencing when used as values
+    if (paramInfo.isCallbackPointerPrimitive) {
+      return false; // Not pass-by-value → will be dereferenced
+    }
+
     // ADR-029: Callback parameters are function pointers
     if (paramInfo.isCallback) {
       return true;
@@ -92,6 +98,12 @@ class ParameterDereferenceResolver {
       return id;
     }
 
+    // Issue #895: Callback-compatible primitives always need dereferencing,
+    // even in C++ mode (because they use pointer semantics to match C typedef)
+    if (paramInfo.forcePointerSemantics) {
+      return `(*${id})`;
+    }
+
     // Known primitive that is pass-by-reference needs dereference
     // Issue #558/#644: In C++ mode, primitives become references
     return deps.maybeDereference(id);

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

@@ -42,6 +42,21 @@ interface IFromASTDeps {
 
   /** Whether the parameter should use pass-by-value (pre-computed) */
   isPassByValue: boolean;
+
+  /** Issue #895: Whether the current function is callback-compatible */
+  isCallbackCompatible: boolean;
+
+  /**
+   * Issue #895: Force pass-by-reference for callback-compatible functions
+   * When the typedef signature requires a pointer, this overrides normal logic.
+   */
+  forcePassByReference?: boolean;
+
+  /**
+   * Issue #895: Force const qualifier from callback typedef signature.
+   * When the C typedef has `const T*`, this preserves const on the generated param.
+   */
+  forceConst?: boolean;
 }
 
 /**
@@ -122,7 +137,15 @@ class ParameterInputAdapter {
     // Determine classification for non-array, non-string types
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
-    const isAutoConst = !deps.isModified && !isConst;
+    // 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)
+    const isPassByReference =
+      deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
 
     return {
       name,
@@ -134,7 +157,12 @@ class ParameterInputAdapter {
       isCallback: false,
       isString: false,
       isPassByValue: deps.isPassByValue,
-      isPassByReference: isKnownStruct || isKnownPrimitive,
+      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: Preserve const from callback typedef signature
+      forceConst: deps.forceConst,
     };
   }
 

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

@@ -103,14 +103,19 @@ class ParameterSignatureBuilder {
   /**
    * Build pass-by-reference parameter signature.
    * C mode: const Point* p
-   * C++ mode: const Point& p
+   * C++ mode: const Point& p (unless forcePointerSyntax)
+   *
+   * Issue #895: When forcePointerSyntax is set, always use pointer syntax
+   * because C callback typedefs expect pointers, not C++ references.
    */
   private static _buildRefParam(
     param: IParameterInput,
     refSuffix: string,
   ): string {
     const constPrefix = this._getConstPrefix(param);
-    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+    // Issue #895: Override refSuffix for callback-compatible functions
+    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
 
   /**
@@ -122,13 +127,16 @@ class ParameterSignatureBuilder {
   }
 
   /**
-   * Get const prefix combining explicit const and auto-const.
-   * Auto-const is applied to unmodified parameters.
+   * Get const prefix combining explicit const, auto-const, and forced const.
+   * Priority: forceConst > isConst > isAutoConst
+   * Issue #895: forceConst preserves const from callback typedef signature.
    */
   private static _getConstPrefix(param: IParameterInput): string {
-    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
-    const explicitConst = param.isConst ? "const " : "";
-    return `${autoConst}${explicitConst}`;
+    // Any source of const results in "const " prefix
+    if (param.forceConst || param.isConst || param.isAutoConst) {
+      return "const ";
+    }
+    return "";
   }
 }
 

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

@@ -11,7 +11,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import CodeGenState from "../../../state/CodeGenState.js";
 import StringUtils from "../../../../utils/StringUtils.js";
-import ExpressionUnwrapper from "../utils/ExpressionUnwrapper.js";
+import ExpressionUnwrapper from "../../../../utils/ExpressionUnwrapper";
 
 /** Regex for identifying valid C/C++ identifiers */
 const IDENTIFIER_REGEX = /^[a-zA-Z_]\w*$/;

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

@@ -0,0 +1,220 @@
+/**
+ * TypedefParamParser - Parses C function pointer typedef signatures
+ *
+ * Extracts parameter types from typedef strings like:
+ *   "void (*)(widget_t *, const rect_t *, uint8_t *)"
+ *   "void (*)(Point p)"
+ *
+ * Used by Issue #895 to determine if callback params should be pointers or values.
+ */
+
+/**
+ * Parsed parameter info from a typedef.
+ */
+interface ITypedefParam {
+  /** Full type string (e.g., "widget_t *", "const rect_t *", "uint8_t *") */
+  type: string;
+  /** Whether this is a pointer type */
+  isPointer: boolean;
+  /** Whether this has const qualifier */
+  isConst: boolean;
+  /** Base type without pointer/const (e.g., "widget_t", "rect_t", "uint8_t") */
+  baseType: string;
+}
+
+/**
+ * Parse result for a typedef signature.
+ */
+interface ITypedefParseResult {
+  /** Return type */
+  returnType: string;
+  /** Parsed parameters */
+  params: ITypedefParam[];
+}
+
+class TypedefParamParser {
+  /**
+   * Parse a function pointer typedef type string.
+   *
+   * @param typedefType - The type string, e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)"
+   * @returns Parsed result with return type and parameters, or null if parsing fails
+   */
+  static parse(typedefType: string): ITypedefParseResult | null {
+    // Expected format: "return_type (*)(param1, param2, ...)"
+    // Find the (*) marker first
+    const funcPtrIndex = typedefType.indexOf("(*)");
+    if (funcPtrIndex === -1) {
+      return null;
+    }
+
+    const returnType = typedefType.substring(0, funcPtrIndex).trim();
+
+    // Find the opening paren after (*)
+    const afterFuncPtr = typedefType.substring(funcPtrIndex + 3).trim();
+    if (!afterFuncPtr.startsWith("(")) {
+      return null;
+    }
+
+    // Extract params by finding the matching closing paren
+    const paramsStr = TypedefParamParser.extractParenContent(afterFuncPtr);
+    if (paramsStr === null) {
+      return null;
+    }
+
+    // Handle void or empty params
+    if (!paramsStr || paramsStr === "void") {
+      return { returnType, params: [] };
+    }
+
+    // Split by comma, handling nested parentheses
+    const paramStrings = TypedefParamParser.splitParams(paramsStr);
+    const params = paramStrings.map((p) => TypedefParamParser.parseParam(p));
+
+    return { returnType, params };
+  }
+
+  /**
+   * Extract content between matching parentheses, handling arbitrary nesting.
+   * @param str - String starting with '('
+   * @returns Content between outer parens, or null if no match
+   */
+  private static extractParenContent(str: string): string | null {
+    if (!str.startsWith("(")) {
+      return null;
+    }
+
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === "(") {
+        depth++;
+      } else if (str[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          // Found matching close paren - return content between
+          return str.substring(1, i);
+        }
+      }
+    }
+
+    // No matching close paren found
+    return null;
+  }
+
+  /**
+   * Split parameter string by commas, respecting nested parentheses.
+   */
+  private static splitParams(paramsStr: string): string[] {
+    const params: string[] = [];
+    let current = "";
+    let depth = 0;
+
+    for (const char of paramsStr) {
+      if (char === "(") {
+        depth++;
+        current += char;
+      } else if (char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+
+    return params;
+  }
+
+  /**
+   * Parse a single parameter type string.
+   */
+  private static parseParam(paramStr: string): ITypedefParam {
+    const trimmed = paramStr.trim();
+
+    // Check for pointer
+    const isPointer = trimmed.includes("*");
+
+    // Check for const - handles both "const " (with space) and merged forms
+    // C grammar getText() strips spaces, so "const rect_t*" may appear merged
+    const isConst = /\bconst\b/.test(trimmed) || trimmed.startsWith("const");
+
+    // Extract base type (remove const, *, and param name if present)
+    let baseType = trimmed
+      .replaceAll(/\bconst\b/g, "") // Remove const (with word boundary)
+      .replace(/^const/, "") // Remove const at start (no space case) - only once
+      .replaceAll("*", "") // Remove pointers
+      .replaceAll(/\s+/g, " ") // Normalize whitespace
+      .trim();
+
+    // Remove trailing param name if present (e.g., "rect_t area" -> "rect_t")
+    // Only remove if there are multiple words (space-separated)
+    if (baseType.includes(" ")) {
+      baseType = baseType.replace(/\s+\w+$/, "");
+    }
+
+    // Handle struct keyword
+    if (baseType.startsWith("struct ")) {
+      baseType = baseType.substring(7);
+    }
+
+    return {
+      type: trimmed,
+      isPointer,
+      isConst,
+      baseType,
+    };
+  }
+
+  /**
+   * Get the parameter info at a given index, or null if not found.
+   */
+  private static getParamAt(
+    typedefType: string,
+    paramIndex: number,
+  ): ITypedefParam | null {
+    const parsed = TypedefParamParser.parse(typedefType);
+    if (!parsed || paramIndex >= parsed.params.length) {
+      return null;
+    }
+    return parsed.params[paramIndex];
+  }
+
+  /**
+   * Check if a parameter at a given index should be a pointer based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be a pointer, false for value, null if unknown
+   */
+  static shouldBePointer(
+    typedefType: string,
+    paramIndex: number,
+  ): boolean | null {
+    return (
+      TypedefParamParser.getParamAt(typedefType, paramIndex)?.isPointer ?? null
+    );
+  }
+
+  /**
+   * Check if a parameter at a given index should be const based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be const, false otherwise, null if unknown
+   */
+  static shouldBeConst(
+    typedefType: string,
+    paramIndex: number,
+  ): boolean | null {
+    return (
+      TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null
+    );
+  }
+}
+
+export default TypedefParamParser;