c-next 0.2.16 → 0.2.17

package/grammar/CNext.g4

@@ -538,10 +538,14 @@ stringType
 
 // C-Next style array type: dimensions in type position
 // Supports: u8[8], u8[4][4], u8[] (unbounded), string<32>[5]
+// Also supports scoped/qualified types: this.Type[4], Scope.Type[4], global.Type[4]
 arrayType
     : primitiveType arrayTypeDimension+
     | userType arrayTypeDimension+
     | stringType arrayTypeDimension+
+    | scopedType arrayTypeDimension+       // this.Type[4] - scoped type array
+    | qualifiedType arrayTypeDimension+    // Scope.Type[4] - qualified type array
+    | globalType arrayTypeDimension+       // global.Type[4] - global type array
     ;
 
 arrayTypeDimension

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",
@@ -24,6 +24,10 @@
     "test:update": "tsx scripts/test.ts --update",
     "integration:transpile": "tsx scripts/test.ts --transpile-only",
     "integration:execute": "tsx scripts/test.ts --execute-only",
+    "test:bugs": "tsx scripts/test.ts -- bugs",
+    "test:bugs:q": "tsx scripts/test.ts -- bugs -q",
+    "integration:bugs:transpile": "tsx scripts/test.ts -- bugs --transpile-only",
+    "integration:bugs:execute": "tsx scripts/test.ts -- bugs --execute-only",
     "analyze": "./scripts/static-analysis.sh",
     "clean": "rm -rf dist src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
     "prettier:check": "prettier --check .",

package/src/transpiler/Transpiler.ts

@@ -1410,8 +1410,15 @@ class Transpiler {
       CodeGenState.symbolTable,
     );
 
+    // ADR-029: Convert callback types to header format
+    const callbackTypesForHeader = this._buildCallbackTypesForHeader();
+
     const typeInputWithSymbolTable = typeInput
-      ? { ...typeInput, symbolTable: CodeGenState.symbolTable }
+      ? {
+          ...typeInput,
+          symbolTable: CodeGenState.symbolTable,
+          callbackTypes: callbackTypesForHeader,
+        }
       : undefined;
 
     const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
@@ -1437,6 +1444,52 @@ class Transpiler {
     );
   }
 
+  /**
+   * ADR-029: Build callback types for header generation.
+   * Only includes callbacks that are actually used as struct field types.
+   * Converts CodeGenState.callbackTypes to the format expected by IHeaderTypeInput.
+   */
+  private _buildCallbackTypesForHeader(): ReadonlyMap<
+    string,
+    {
+      typedefName: string;
+      returnType: string;
+      parameters: ReadonlyArray<{ type: string; isStruct: boolean }>;
+    }
+  > {
+    const result = new Map<
+      string,
+      {
+        typedefName: string;
+        returnType: string;
+        parameters: ReadonlyArray<{ type: string; isStruct: boolean }>;
+      }
+    >();
+
+    // Collect callback function names that are actually used as struct field types
+    const usedCallbackTypes = new Set<string>();
+    for (const [, funcName] of CodeGenState.callbackFieldTypes) {
+      usedCallbackTypes.add(funcName);
+    }
+
+    // Only include callbacks that are used as struct field types
+    for (const funcName of usedCallbackTypes) {
+      const cbInfo = CodeGenState.callbackTypes.get(funcName);
+      if (cbInfo) {
+        result.set(funcName, {
+          typedefName: cbInfo.typedefName,
+          returnType: cbInfo.returnType,
+          parameters: cbInfo.parameters.map((p) => ({
+            type: p.type,
+            isStruct: p.isStruct,
+          })),
+        });
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Collect external enum sources from included C-Next files.
    */
@@ -1509,6 +1562,9 @@ class Transpiler {
 
       // Issue #914: For callback-compatible functions, bake pointer/const overrides
       // onto each parameter. Skip auto-const (matches CodeGenerator path).
+      // Note: isOpaqueHandle is not set here because callback params get their
+      // pointer/const semantics from the typedef signature via isCallbackPointer/
+      // isCallbackConst, which take precedence over opaque handling in the builder.
       if (callbackTypedefType) {
         const updatedParams = TypedefParamParser.resolveCallbackParams(
           headerSymbol.parameters,
@@ -1517,29 +1573,41 @@ class Transpiler {
         return { ...headerSymbol, parameters: updatedParams };
       }
 
-      // Apply auto-const to non-callback function parameters
+      // Apply auto-const and resolve opaque type info for 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 };
-      }
+      const updatedParams = headerSymbol.parameters.map((param) => {
+        // Issue #995: Resolve opaque type info ONCE onto the symbol.
+        // This is the single source of truth for both body (.c/.cpp) and header (.h/.hpp).
+        const isOpaque = CodeGenState.isOpaqueType(param.type ?? "");
+
+        // ADR-006: Only non-array pointer params get auto-const.
+        // Arrays are pass-by-reference and mutable by default - auto-const would
+        // break compatibility with C APIs expecting mutable pointers (issue #986).
+        // Note: isAutoConst may be set here, but ParameterSignatureBuilder will
+        // suppress it for opaque handles (Issue #995) — single source of truth.
+        const isPointerParam =
+          !param.isConst &&
+          !param.isArray &&
+          param.type !== "f32" &&
+          param.type !== "f64" &&
+          param.type !== "ISR" &&
+          !knownEnums.has(param.type ?? "");
+
+        const shouldAutoConst =
+          unmodified && isPointerParam && unmodified.has(param.name);
+
+        // Return updated param with resolved flags
+        if (shouldAutoConst || isOpaque) {
+          return {
+            ...param,
+            isAutoConst: shouldAutoConst || undefined,
+            isOpaqueHandle: isOpaque || undefined,
+          };
+        }
+        return param;
+      });
 
-      return headerSymbol;
+      return { ...headerSymbol, parameters: updatedParams };
     });
   }
 

package/src/transpiler/__tests__/DualCodePaths.test.ts

@@ -110,7 +110,7 @@ void main() {
 
     it("produces identical code for const arrays with inferred size", async () => {
       const source = `
-const u8 VALUES[] <- [1, 2, 3, 4, 5];
+const u8[] VALUES <- [1, 2, 3, 4, 5];
 
 void main() {
     u8 x <- VALUES[0];

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

@@ -315,7 +315,10 @@ class FunctionCallListener extends CNextListener {
     if (!baseName) return;
 
     // Walk through postfix ops to find the call and resolve the name
-    const { resolvedName, foundCall } = this.resolveCallTarget(ops, baseName);
+    const { resolvedName, foundCall, isGlobalCall } = this.resolveCallTarget(
+      ops,
+      baseName,
+    );
     if (!foundCall) return;
 
     // Check if the function is defined
@@ -325,6 +328,7 @@ class FunctionCallListener extends CNextListener {
       line,
       column,
       this.currentScope,
+      isGlobalCall,
     );
   };
 
@@ -340,6 +344,9 @@ class FunctionCallListener extends CNextListener {
     if (primary.THIS()) {
       return "this";
     }
+    if (primary.GLOBAL()) {
+      return "global";
+    }
     return null;
   }
 
@@ -351,15 +358,21 @@ class FunctionCallListener extends CNextListener {
   private resolveCallTarget(
     ops: Parser.PostfixOpContext[],
     baseName: string,
-  ): { resolvedName: string; foundCall: boolean } {
+  ): { resolvedName: string; foundCall: boolean; isGlobalCall: boolean } {
     let resolvedName = baseName;
+    let isGlobalCall = baseName === "global";
 
     for (const op of ops) {
       // Member access: check if it's Scope.member or this.member pattern
       if (op.IDENTIFIER()) {
         const resolved = this.resolveMemberAccess(resolvedName, op);
         if (resolved === null) {
-          return { resolvedName, foundCall: false };
+          return { resolvedName, foundCall: false, isGlobalCall };
+        }
+        // If resolution went through a known scope, this is a scope
+        // method call, not a global function lookup
+        if (isGlobalCall && this.analyzer.isScope(resolvedName)) {
+          isGlobalCall = false;
         }
         resolvedName = resolved;
         continue;
@@ -369,12 +382,12 @@ class FunctionCallListener extends CNextListener {
       if (op.argumentList() || op.getChildCount() === 2) {
         const text = op.getText();
         if (text.startsWith("(")) {
-          return { resolvedName, foundCall: true };
+          return { resolvedName, foundCall: true, isGlobalCall };
         }
       }
     }
 
-    return { resolvedName, foundCall: false };
+    return { resolvedName, foundCall: false, isGlobalCall };
   }
 
   /**
@@ -391,6 +404,11 @@ class FunctionCallListener extends CNextListener {
       return `${this.currentScope}_${memberName}`;
     }
 
+    // Issue #985: Handle global.member -> member (strip global prefix)
+    if (resolvedName === "global") {
+      return memberName;
+    }
+
     // Check if base is a known scope
     if (this.analyzer.isScope(resolvedName)) {
       return `${resolvedName}_${memberName}`;
@@ -934,12 +952,14 @@ class FunctionCallAnalyzer {
    * @param line Source line number
    * @param column Source column number
    * @param currentScope The current scope name (if inside a scope)
+   * @param isGlobalCall Whether the call used global. prefix
    */
   public checkFunctionCall(
     name: string,
     line: number,
     column: number,
     currentScope: string | null,
+    isGlobalCall: boolean = false,
   ): void {
     // Check for self-recursion (MISRA C:2012 Rule 17.2)
     if (this.currentFunctionName && name === this.currentFunctionName) {
@@ -981,7 +1001,8 @@ class FunctionCallAnalyzer {
     // ADR-057: Allow implicit scope function calls without this. prefix
     // Check if this is an unqualified call to a scope function
     // e.g., calling helper() instead of this.helper() inside a scope
-    if (currentScope) {
+    // Skip for global. calls — global. explicitly means global scope
+    if (currentScope && !isGlobalCall) {
       const qualifiedName = `${currentScope}_${name}`;
       if (this.definedFunctions.has(qualifiedName)) {
         return; // OK - implicit resolution will handle it
@@ -989,11 +1010,15 @@ class FunctionCallAnalyzer {
     }
 
     // Not defined - report error with optional hint
+    // If the function is local (defined later in this file), it's a
+    // define-before-use error regardless of global. prefix
+    const isLocalFunction = this.allLocalFunctions.has(name);
     const header = this.findStdlibHeader(name);
-    let message = `function '${name}' called before definition`;
-    if (header) {
-      message += `; hint: '${name}' is available from ${header} — try global.${name}()`;
-    }
+    const message = this.buildUndefinedFunctionMessage(
+      name,
+      header,
+      isGlobalCall && !isLocalFunction,
+    );
 
     this.errors.push({
       code: "E0422",
@@ -1004,6 +1029,28 @@ class FunctionCallAnalyzer {
     });
   }
 
+  /**
+   * Issue #985: Build error message for undefined function calls.
+   * Adjusts hint based on whether the call used global. prefix.
+   */
+  private buildUndefinedFunctionMessage(
+    name: string,
+    header: string | null,
+    isGlobalCall: boolean,
+  ): string {
+    if (isGlobalCall && header) {
+      return `'${name}' is not declared in any included header; add #include <${header}>`;
+    }
+    if (isGlobalCall) {
+      return `'${name}' is not declared in any included header`;
+    }
+    let message = `function '${name}' called before definition`;
+    if (header) {
+      message += `; hint: '${name}' is available from ${header} — try global.${name}()`;
+    }
+    return message;
+  }
+
   /**
    * Check if a function is defined externally (from included files)
    * This includes C/C++ headers AND C-Next includes.

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

@@ -157,10 +157,32 @@ class InitializationListener extends CNextListener {
       return;
     }
 
-    // Simple variable assignment: x <- value (no postfix ops)
+    // Resolve the assignment target ONCE (single source of truth)
+    const target = this._resolveAssignmentTarget(baseId, postfixOps);
+
+    // Issue #1012: Compound assignment reads the LHS before writing.
+    // Check if the assignment operator is a compound operator (not simple `<-`).
+    const isCompoundAssignment = ctx.assignmentOperator().ASSIGN() === null;
+    if (isCompoundAssignment) {
+      const { line, column } = ParserUtils.getPosition(ctx);
+      this.analyzer.checkRead(target.varName, line, column, target.fieldName);
+    }
+
+    // Record the assignment to the resolved target
+    this.analyzer.recordAssignment(target.varName, target.fieldName);
+  };
+
+  /**
+   * Resolve an assignment target to its variable name and optional field name.
+   * Single classification path used by both read checks and assignment recording.
+   */
+  private _resolveAssignmentTarget(
+    baseId: string,
+    postfixOps: Parser.PostfixTargetOpContext[],
+  ): { varName: string; fieldName?: string } {
+    // Simple variable: x <- value (no postfix ops)
     if (postfixOps.length === 0) {
-      this.analyzer.recordAssignment(baseId);
-      return;
+      return { varName: baseId };
     }
 
     // Analyze postfix operations
@@ -168,15 +190,13 @@ class InitializationListener extends CNextListener {
 
     // Member access: p.x <- value (struct field)
     if (identifiers.length >= 2 && !hasSubscript) {
-      const varName = identifiers[0];
-      const fieldName = identifiers[1];
-      this.analyzer.recordAssignment(varName, fieldName);
-    } else {
-      // Array access or mixed: arr[i] <- value or arr[i].field <- value
-      // Consider the array/base as a whole initialized
-      this.analyzer.recordAssignment(baseId);
+      return { varName: identifiers[0], fieldName: identifiers[1] };
     }
-  };
+
+    // Array access or mixed: arr[i] <- value or arr[i].field <- value
+    // Consider the array/base as a whole
+    return { varName: baseId };
+  }
 
   // ========================================================================
   // Function Call Arguments (ADR-006: pass-by-reference may initialize)
@@ -526,14 +546,159 @@ class InitializationAnalyzer {
 
   /**
    * Process scope member variable declarations (ADR-016)
+   * Issue #1019: Scope members require explicit initialization like locals
    */
   private _processScopeMembers(decl: Parser.DeclarationContext): void {
     const scopeDecl = decl.scopeDeclaration();
     if (!scopeDecl) return;
 
     const scopeName = scopeDecl.IDENTIFIER().getText();
+
+    // Phase 1: Find all members assigned in any scope function
+    const assignedMembers = this._findAssignedScopeMembers(scopeDecl);
+
+    // Phase 2: Process each member with assignment info
+    for (const member of scopeDecl.scopeMember()) {
+      this._processScopeMemberVariable(member, scopeName, assignedMembers);
+    }
+  }
+
+  /**
+   * Scan all functions in a scope to find which members are assigned.
+   * Issue #1019: A member assigned in ANY function is considered initialized
+   * for reads in other functions within the same scope.
+   */
+  private _findAssignedScopeMembers(
+    scopeDecl: Parser.ScopeDeclarationContext,
+  ): Set<string> {
+    const assigned = new Set<string>();
+
     for (const member of scopeDecl.scopeMember()) {
-      this._processScopeMemberVariable(member, scopeName);
+      const funcDecl = member.functionDeclaration();
+      if (!funcDecl) continue;
+
+      const body = funcDecl.block();
+      if (!body) continue;
+
+      // Scan the function body for assignments to scope members
+      this._collectAssignmentsInBlock(body, assigned);
+    }
+
+    return assigned;
+  }
+
+  /**
+   * Recursively collect variable names that are assigned in a block.
+   * Looks for assignment statements targeting bare identifiers or this.member.
+   */
+  private _collectAssignmentsInBlock(
+    block: Parser.BlockContext,
+    assigned: Set<string>,
+  ): void {
+    for (const stmt of block.statement()) {
+      this._collectAssignmentsInStatement(stmt, assigned);
+    }
+  }
+
+  /**
+   * Collect assignments from a single statement, recursing into nested blocks.
+   */
+  private _collectAssignmentsInStatement(
+    stmt: Parser.StatementContext,
+    assigned: Set<string>,
+  ): void {
+    this._collectDirectAssignment(stmt, assigned);
+    this._collectFromControlFlow(stmt, assigned);
+    this._collectFromSwitch(stmt, assigned);
+    this._collectFromBlock(stmt, assigned);
+  }
+
+  /**
+   * Collect assignment from the statement itself (if it's an assignment).
+   */
+  private _collectDirectAssignment(
+    stmt: Parser.StatementContext,
+    assigned: Set<string>,
+  ): void {
+    const assignStmt = stmt.assignmentStatement();
+    if (!assignStmt) return;
+
+    const target = assignStmt.assignmentTarget();
+    if (!target) return;
+
+    // Both bare identifier and this.member use the same IDENTIFIER token
+    const id = target.IDENTIFIER()?.getText();
+    if (id) {
+      assigned.add(id);
+    }
+  }
+
+  /**
+   * Recurse into control flow statements (if, while, do-while, for).
+   */
+  private _collectFromControlFlow(
+    stmt: Parser.StatementContext,
+    assigned: Set<string>,
+  ): void {
+    // if statement
+    const ifStmt = stmt.ifStatement();
+    if (ifStmt) {
+      for (const childStmt of ifStmt.statement()) {
+        this._collectAssignmentsInStatement(childStmt, assigned);
+      }
+    }
+
+    // while statement
+    const whileBody = stmt.whileStatement()?.statement();
+    if (whileBody) {
+      this._collectAssignmentsInStatement(whileBody, assigned);
+    }
+
+    // do-while statement (Issue #1019 review feedback)
+    const doWhileBody = stmt.doWhileStatement()?.block();
+    if (doWhileBody) {
+      this._collectAssignmentsInBlock(doWhileBody, assigned);
+    }
+
+    // for statement
+    const forBody = stmt.forStatement()?.statement();
+    if (forBody) {
+      this._collectAssignmentsInStatement(forBody, assigned);
+    }
+  }
+
+  /**
+   * Recurse into switch statement cases.
+   */
+  private _collectFromSwitch(
+    stmt: Parser.StatementContext,
+    assigned: Set<string>,
+  ): void {
+    const switchStmt = stmt.switchStatement();
+    if (!switchStmt) return;
+
+    for (const switchCase of switchStmt.switchCase()) {
+      const caseBlock = switchCase.block();
+      if (caseBlock) {
+        this._collectAssignmentsInBlock(caseBlock, assigned);
+      }
+    }
+    const defaultBlock = switchStmt.defaultCase()?.block();
+    if (defaultBlock) {
+      this._collectAssignmentsInBlock(defaultBlock, assigned);
+    }
+  }
+
+  /**
+   * Recurse into standalone block statement.
+   */
+  private _collectFromBlock(
+    stmt: Parser.StatementContext,
+    assigned: Set<string>,
+  ): void {
+    const block = stmt.block();
+    if (block) {
+      this._collectAssignmentsInBlock(block, assigned);
     }
   }
 
@@ -543,6 +708,7 @@ class InitializationAnalyzer {
   private _processScopeMemberVariable(
     member: Parser.ScopeMemberContext,
     scopeName: string,
+    assignedMembers: Set<string>,
   ): void {
     const memberVar = member.variableDeclaration();
     if (!memberVar) return;
@@ -552,9 +718,15 @@ class InitializationAnalyzer {
     const { line, column } = ParserUtils.getPosition(memberVar);
     const typeName = this._extractUserTypeName(memberVar.type());
 
+    // Issue #1019: Scope members are initialized if they have an inline
+    // initializer OR are assigned in any function within the scope
+    const hasInlineInit = memberVar.expression() !== null;
+    const isAssignedInScope = assignedMembers.has(varName);
+    const hasInitializer = hasInlineInit || isAssignedInScope;
+
     // Register with both raw name and transpiled C name for scope resolution
-    this.declareVariable(varName, line, column, true, typeName);
-    this.declareVariable(fullName, line, column, true, typeName);
+    this.declareVariable(varName, line, column, hasInitializer, typeName);
+    this.declareVariable(fullName, line, column, hasInitializer, typeName);
   }
 
   /**