c-next 0.2.16 → 0.2.18

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

@@ -14,7 +14,12 @@
  * 1. It's a small primitive type (u8, i8, u16, i16, u32, i32, u64, i64, bool)
  * 2. It's not modified (directly or transitively)
  * 3. It's not an array, struct, string, or callback
- * 4. It's not accessed via subscript (Issue #579)
+ *
+ * Issue #1100: Subscript access no longer forces pointer semantics on its
+ * own. A scalar parameter subscripted with a single index is bit-indexing
+ * (ADR-007), not array access, so it stays eligible for pass-by-value.
+ * Only genuine array parameters (`isArray`, from explicit `T[N]` syntax,
+ * ADR-006) are excluded — via the isArray check below.
  */
 
 import * as Parser from "../parser/grammar/CNextParser";
@@ -173,8 +178,6 @@ class PassByValueAnalyzer {
 
     // Initialize modified set
     CodeGenState.modifiedParameters.set(funcName, new Set());
-    // Issue #579: Initialize subscript access tracking
-    CodeGenState.subscriptAccessedParameters.set(funcName, new Set());
     CodeGenState.functionCallGraph.set(funcName, []);
 
     // Walk the function body to find modifications and calls
@@ -225,15 +228,9 @@ class PassByValueAnalyzer {
       );
     }
 
-    // 2. Walk all expressions in this statement for function calls and subscript access
+    // 2. Walk all expressions in this statement for function calls
     for (const expr of StatementExpressionCollector.collectAll(stmt)) {
       PassByValueAnalyzer.walkExpressionForCalls(funcName, paramSet, expr);
-      // Issue #579: Also track subscript read access on parameters
-      PassByValueAnalyzer.walkExpressionForSubscriptAccess(
-        funcName,
-        paramSet,
-        expr,
-      );
     }
 
     // 3. Recurse into child statements and blocks
@@ -266,21 +263,11 @@ class PassByValueAnalyzer {
     const assign = stmt.assignmentStatement()!;
     const target = assign.assignmentTarget();
 
-    const { baseIdentifier, hasSingleIndexSubscript } =
-      AssignmentTargetExtractor.extract(target);
-
-    // Issue #579: Track subscript access on parameters (for write path)
-    if (
-      hasSingleIndexSubscript &&
-      baseIdentifier &&
-      paramSet.has(baseIdentifier)
-    ) {
-      CodeGenState.subscriptAccessedParameters
-        .get(funcName)!
-        .add(baseIdentifier);
-    }
+    const { baseIdentifier } = AssignmentTargetExtractor.extract(target);
 
-    // Track as modified parameter
+    // Track as modified parameter (covers both `x <- value` and subscripted
+    // writes like `x[i] <- value` / `x[4] <- true` — both change x's value,
+    // so x must pass by pointer for the caller to observe the change)
     if (baseIdentifier && paramSet.has(baseIdentifier)) {
       CodeGenState.modifiedParameters.get(funcName)!.add(baseIdentifier);
     }
@@ -309,67 +296,9 @@ class PassByValueAnalyzer {
     }
   }
 
-  /**
-   * Issue #579: Walk an expression tree to find subscript access on parameters.
-   * This tracks read access like `buf[i]` where buf is a parameter.
-   * Parameters with subscript access must become pointers.
-   */
-  private static walkExpressionForSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    expr: Parser.ExpressionContext,
-  ): void {
-    const ternary = expr.ternaryExpression();
-    if (ternary) {
-      for (const orExpr of ternary.orExpression()) {
-        PassByValueAnalyzer.walkOrExpression(orExpr, (unaryExpr) => {
-          PassByValueAnalyzer.handleSubscriptAccess(
-            funcName,
-            paramSet,
-            unaryExpr,
-          );
-        });
-      }
-    }
-  }
-
-  /**
-   * Issue #579: Handle subscript access on a unary expression.
-   * Only tracks single-index subscript access (which could be array access).
-   * Two-index subscript (e.g., value[start, width]) is always bit extraction,
-   * so it doesn't require the parameter to become a pointer.
-   */
-  private static handleSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    unaryExpr: Parser.UnaryExpressionContext,
-  ): void {
-    const postfixExpr = unaryExpr.postfixExpression();
-    if (!postfixExpr) return;
-
-    const primary = postfixExpr.primaryExpression();
-    const ops = postfixExpr.postfixOp();
-
-    // Check if primary is a parameter and there's subscript access
-    const primaryId = primary.IDENTIFIER()?.getText();
-    if (!primaryId || !paramSet.has(primaryId)) {
-      return;
-    }
-
-    // Only track SINGLE-index subscript access (potential array access)
-    // Two-index subscript like value[0, 8] is bit extraction, not array access
-    const hasSingleIndexSubscript = ops.some(
-      (op) => op.expression().length === 1,
-    );
-    if (hasSingleIndexSubscript) {
-      CodeGenState.subscriptAccessedParameters.get(funcName)!.add(primaryId);
-    }
-  }
-
   /**
    * Generic walker for orExpression trees.
    * Walks through the expression hierarchy and calls the handler for each unaryExpression.
-   * Used by both function call tracking and subscript access tracking.
    */
   private static walkOrExpression(
     orExpr: Parser.OrExpressionContext,
@@ -671,24 +600,14 @@ class PassByValueAnalyzer {
 
           // Check if eligible for pass-by-value:
           // - Is a small primitive type
-          // - Not an array
-          // - Not modified
-          // - Not accessed via subscript (Issue #579)
+          // - Not an array (array parameters always decay to pointers, ADR-006)
+          // - Not modified (a subscripted bit-write, e.g. `x[4] <- true`, counts
+          //   as a modification and is already tracked in `modified` above)
           const isSmallPrimitive = SMALL_PRIMITIVES.has(paramSig.baseType);
           const isArray = paramSig.isArray ?? false;
           const isModified = modified.has(paramName);
-          // Issue #579: Parameters with subscript access must become pointers
-          const hasSubscriptAccess =
-            CodeGenState.subscriptAccessedParameters
-              .get(funcName)
-              ?.has(paramName) ?? false;
-
-          if (
-            isSmallPrimitive &&
-            !isArray &&
-            !isModified &&
-            !hasSubscriptAccess
-          ) {
+
+          if (isSmallPrimitive && !isArray && !isModified) {
             passByValue.add(paramName);
           }
         }

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

@@ -0,0 +1,171 @@
+/**
+ * Return-Path Analyzer
+ * ADR-112 / Issue #1040: reject a non-void function that can reach the end of
+ * its body without returning a value (undefined behavior in C).
+ *
+ * The analysis is intentionally strict and conservative (sound): it never
+ * accepts a function that might fall through, and it does not attempt to prove
+ * that loops are infinite or that a switch over an enum is exhaustive. Where it
+ * cannot prove a return, an explicit `return <value>` is required.
+ *
+ * C-Next has no break/continue (ADR-026), so loop bodies have no early
+ * structural exits to reason about.
+ */
+
+import { ParseTreeWalker } from "antlr4ng";
+import { CNextListener } from "../parser/grammar/CNextListener";
+import * as Parser from "../parser/grammar/CNextParser";
+import IReturnPathError from "./types/IReturnPathError";
+
+/**
+ * Does executing this statement guarantee that the enclosing function returns a
+ * value before control passes beyond it?
+ */
+function statementDefinitelyReturns(ctx: Parser.StatementContext): boolean {
+  const returnStmt = ctx.returnStatement();
+  if (returnStmt) {
+    // A bare `return;` (no expression) returns no value, so it does not satisfy
+    // a non-void function.
+    return returnStmt.expression() !== null;
+  }
+
+  const ifStmt = ctx.ifStatement();
+  if (ifStmt) {
+    return ifDefinitelyReturns(ifStmt);
+  }
+
+  const switchStmt = ctx.switchStatement();
+  if (switchStmt) {
+    return switchDefinitelyReturns(switchStmt);
+  }
+
+  const doWhileStmt = ctx.doWhileStatement();
+  if (doWhileStmt) {
+    // The body always executes at least once.
+    return blockDefinitelyReturns(doWhileStmt.block());
+  }
+
+  if (ctx.foreverStatement()) {
+    // ADR-113: a `forever` loop is divergent — C-Next has no break/continue
+    // (ADR-026), so control never passes beyond it. It is therefore a terminal
+    // path, like an unconditional return, and the function never falls through
+    // here. This is the shared "divergence" primitive ADR-114 (#849) reuses.
+    //
+    // `forever` is void-only (E0705, enforced in codegen). Marking it terminal
+    // here keeps a non-void function containing a `forever` loop from emitting a
+    // misleading E0704 ("must return a value") instead of the precise E0705.
+    return true;
+  }
+
+  const block = ctx.block();
+  if (block) {
+    return blockDefinitelyReturns(block);
+  }
+
+  const criticalStmt = ctx.criticalStatement();
+  if (criticalStmt) {
+    return blockDefinitelyReturns(criticalStmt.block());
+  }
+
+  // while / for (the body may not execute), variable declarations, assignments,
+  // and expression statements never guarantee a return on their own.
+  return false;
+}
+
+/**
+ * A block guarantees a return iff any of its statements does: statements after
+ * an unconditional return are unreachable.
+ */
+function blockDefinitelyReturns(ctx: Parser.BlockContext): boolean {
+  return ctx.statement().some(statementDefinitelyReturns);
+}
+
+/**
+ * An if guarantees a return only when an `else` is present and both branches
+ * guarantee a return. `else if` chains recurse through the else branch.
+ */
+function ifDefinitelyReturns(ctx: Parser.IfStatementContext): boolean {
+  const branches = ctx.statement();
+  if (branches.length < 2) {
+    return false;
+  }
+  return (
+    statementDefinitelyReturns(branches[0]) &&
+    statementDefinitelyReturns(branches[1])
+  );
+}
+
+/**
+ * A switch guarantees a return only when a `default` is present and every case
+ * block and the default block guarantee a return.
+ */
+function switchDefinitelyReturns(ctx: Parser.SwitchStatementContext): boolean {
+  const defaultCase = ctx.defaultCase();
+  if (!defaultCase) {
+    return false;
+  }
+  const everyCaseReturns = ctx
+    .switchCase()
+    .every((switchCase) => blockDefinitelyReturns(switchCase.block()));
+  return everyCaseReturns && blockDefinitelyReturns(defaultCase.block());
+}
+
+/**
+ * Listener that flags non-void functions whose body can fall through.
+ */
+class ReturnPathListener extends CNextListener {
+  private readonly analyzer: ReturnPathAnalyzer;
+
+  constructor(analyzer: ReturnPathAnalyzer) {
+    super();
+    this.analyzer = analyzer;
+  }
+
+  override enterFunctionDeclaration = (
+    ctx: Parser.FunctionDeclarationContext,
+  ): void => {
+    // Void functions are allowed to fall off the end.
+    if (ctx.type().getText() === "void") {
+      return;
+    }
+
+    if (blockDefinitelyReturns(ctx.block())) {
+      return;
+    }
+
+    const identifier = ctx.IDENTIFIER();
+    this.analyzer.addError(
+      identifier.getText(),
+      identifier.symbol.line,
+      identifier.symbol.column,
+    );
+  };
+}
+
+/**
+ * Analyzer for missing return paths (ADR-112).
+ */
+class ReturnPathAnalyzer {
+  private errors: IReturnPathError[] = [];
+
+  public analyze(tree: Parser.ProgramContext): IReturnPathError[] {
+    this.errors = [];
+    const listener = new ReturnPathListener(this);
+    ParseTreeWalker.DEFAULT.walk(listener, tree);
+    return this.errors;
+  }
+
+  public addError(functionName: string, line: number, column: number): void {
+    this.errors.push({
+      code: "E0704",
+      functionName,
+      line,
+      column,
+      message: `Non-void function '${functionName}' must return a value on all paths`,
+      helpText:
+        "Add an explicit 'return <value>;' so every control-flow path returns a value",
+    });
+  }
+}
+
+export default ReturnPathAnalyzer;

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

@@ -21,6 +21,7 @@ import ISignedShiftError from "./types/ISignedShiftError";
 import ParserUtils from "../../../utils/ParserUtils";
 import TypeConstants from "../../../utils/constants/TypeConstants";
 import ExpressionUtils from "../../../utils/ExpressionUtils";
+import CodeGenState from "../../state/CodeGenState";
 
 /**
  * First pass: Collect variable declarations with their types
@@ -28,25 +29,36 @@ import ExpressionUtils from "../../../utils/ExpressionUtils";
 class SignedVariableCollector extends CNextListener {
   private readonly signedVars: Set<string> = new Set();
 
+  // Track all variable types (for resolving struct member chains)
+  private readonly varTypes: Map<string, string> = new Map();
+
   public getSignedVars(): Set<string> {
     return this.signedVars;
   }
 
+  public getVarTypes(): Map<string, string> {
+    return this.varTypes;
+  }
+
   /**
-   * Track a typed identifier if it has a signed type
+   * Track a typed identifier - add to signedVars if signed, always track type
    */
-  private trackIfSigned(
+  private trackType(
     typeCtx: Parser.TypeContext | null,
     identifier: { getText(): string } | null,
   ): void {
-    if (!typeCtx) return;
+    if (!typeCtx || !identifier) return;
 
     const typeName = typeCtx.getText();
-    if (!TypeConstants.SIGNED_TYPES.includes(typeName)) return;
+    const varName = identifier.getText();
 
-    if (!identifier) return;
+    // Always track the variable's type for member chain resolution
+    this.varTypes.set(varName, typeName);
 
-    this.signedVars.add(identifier.getText());
+    // Also track in signedVars if it's a signed type
+    if (TypeConstants.SIGNED_TYPES.includes(typeName)) {
+      this.signedVars.add(varName);
+    }
   }
 
   /**
@@ -55,21 +67,21 @@ class SignedVariableCollector extends CNextListener {
   override enterVariableDeclaration = (
     ctx: Parser.VariableDeclarationContext,
   ): void => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
 
   /**
    * Track function parameters with signed types
    */
   override enterParameter = (ctx: Parser.ParameterContext): void => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
 
   /**
    * Track for-loop variable declarations with signed types
    */
   override enterForVarDecl = (ctx: Parser.ForVarDeclContext): void => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
 }
 
@@ -82,10 +94,18 @@ class SignedShiftListener extends CNextListener {
   // eslint-disable-next-line @typescript-eslint/lines-between-class-members
   private readonly signedVars: Set<string>;
 
-  constructor(analyzer: SignedShiftAnalyzer, signedVars: Set<string>) {
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  private readonly varTypes: Map<string, string>;
+
+  constructor(
+    analyzer: SignedShiftAnalyzer,
+    signedVars: Set<string>,
+    varTypes: Map<string, string>,
+  ) {
     super();
     this.analyzer = analyzer;
     this.signedVars = signedVars;
+    this.varTypes = varTypes;
   }
 
   /**
@@ -116,6 +136,97 @@ class SignedShiftListener extends CNextListener {
     }
   };
 
+  /**
+   * Check compound shift-assign statements for signed targets
+   * assignmentStatement: assignmentTarget assignmentOperator expression ';'
+   * Issue #1008: <<<- and >><- must also be rejected on signed types
+   *
+   * Handles both simple identifiers (x <<<- 2) and member chains (s.x <<<- 2)
+   */
+  override enterAssignmentStatement = (
+    ctx: Parser.AssignmentStatementContext,
+  ): void => {
+    const opCtx = ctx.assignmentOperator();
+    if (!opCtx) return;
+
+    const isLeftShiftAssign = opCtx.LSHIFT_ASSIGN() !== null;
+    const isRightShiftAssign = opCtx.RSHIFT_ASSIGN() !== null;
+    if (!isLeftShiftAssign && !isRightShiftAssign) return;
+
+    const target = ctx.assignmentTarget();
+    if (!target) return;
+
+    // Get the base identifier from the assignment target
+    const identifier = target.IDENTIFIER();
+    if (!identifier) return;
+
+    const baseName = identifier.getText();
+    const postfixOps = target.postfixTargetOp();
+
+    // Check if the final target type is signed
+    if (this.isSignedTarget(baseName, postfixOps)) {
+      const operator = isLeftShiftAssign ? "<<<-" : ">><-";
+      const { line, column } = ParserUtils.getPosition(target);
+      this.analyzer.addError(line, column, operator);
+    }
+  };
+
+  /**
+   * Resolve the final type of an assignment target, handling member chains.
+   * Returns true if the final target is a signed type.
+   *
+   * Examples:
+   *   - "x" with no postfix ops → check if x is signed
+   *   - "s" with postfixOps [".x"] → check if s.x field is signed
+   *   - "arr" with postfixOps ["[0]", ".field"] → check if field is signed
+   */
+  private isSignedTarget(
+    baseName: string,
+    postfixOps: Parser.PostfixTargetOpContext[],
+  ): boolean {
+    // Simple case: no member access, just a variable
+    if (postfixOps.length === 0) {
+      return this.signedVars.has(baseName);
+    }
+
+    // Member chain case: resolve through the chain
+    let currentType = this.varTypes.get(baseName);
+    if (!currentType) {
+      // Unknown base type - can't resolve, skip
+      return false;
+    }
+
+    // Walk through the postfix operations
+    for (const op of postfixOps) {
+      const memberIdent = op.IDENTIFIER();
+      if (memberIdent) {
+        // Member access: .fieldName
+        const fieldName = memberIdent.getText();
+        const fieldType = CodeGenState.getStructFieldType(
+          currentType,
+          fieldName,
+        );
+        if (!fieldType) {
+          // Unknown field - can't resolve, skip
+          return false;
+        }
+        currentType = fieldType;
+      } else {
+        // Array subscript: [expr] - doesn't change the base type for primitives
+        // For arrays like u8[4], after [i] we still have u8
+        // Strip array dimensions if present
+        const bracketIndex = currentType.indexOf("[");
+        if (bracketIndex !== -1) {
+          currentType = currentType.substring(0, bracketIndex);
+        }
+        // Otherwise keep the type as-is (e.g., bit indexing on u8)
+      }
+    }
+
+    // Check if the final resolved type is signed
+    return TypeConstants.SIGNED_TYPES.includes(currentType);
+  }
+
   /**
    * Check if an additive expression contains a signed type operand
    */
@@ -202,13 +313,14 @@ class SignedShiftAnalyzer {
   public analyze(tree: Parser.ProgramContext): ISignedShiftError[] {
     this.errors = [];
 
-    // First pass: collect signed variables
+    // First pass: collect signed variables and all variable types
     const collector = new SignedVariableCollector();
     ParseTreeWalker.DEFAULT.walk(collector, tree);
     const signedVars = collector.getSignedVars();
+    const varTypes = collector.getVarTypes();
 
     // Second pass: detect shift with signed operands
-    const listener = new SignedShiftListener(this, signedVars);
+    const listener = new SignedShiftListener(this, signedVars, varTypes);
     ParseTreeWalker.DEFAULT.walk(listener, tree);
 
     return this.errors;