refactor(compiler): simplify logical or conditional lowering

Rename the OR fallback lowering path around its onTrue/onFalse contract, share scalar comparison extraction, and gate base conditions once before entering OR fallback selection.

Add E2E coverage for heap-string fallback, tuple fallback, and nested value-position OR expressions.

Author: thiremani

compiler/compiler.go

@@ -1720,6 +1720,8 @@ func (c *Compiler) compileInfixBasic(expr *ast.InfixExpression, info *ExprInfo)
 			// Usually pre-extracted via condLHS, but can still occur when range
 			// comparisons are scalarized by an outer loop (e.g. call arg vectorization).
 			res = append(res, c.compileCondScalar(expr.Operator, left[i], right[i]))
+		case CondOr:
+			panic("internal: value-position logical OR must be lowered through conditional expression branching")
 		default:
 			res = append(res, c.compileInfix(expr.Operator, left[i], right[i], info.OutTypes[i]))
 		}

compiler/cond.go

@@ -475,23 +475,9 @@ func (c *Compiler) extractCondExprs(expr ast.Expression, cond llvm.Value, temps
 	// Comparisons with ranges can be extracted only when all required iterators
 	// are already bound by an outer loop (no pending ranges).
 	if infix, ok := expr.(*ast.InfixExpression); ok && info.HasCondScalar() && len(c.pendingLoopRanges(info.Ranges)) == 0 {
-		// Bottom-up: extract conditions from operands first
 		cond, temps = c.extractCondExprs(infix.Left, cond, temps)
 		cond, temps = c.extractCondExprs(infix.Right, cond, temps)
-
-		// Compile both operands (may return pre-extracted values)
-		left := c.compileExpression(infix.Left, nil)
-		right := c.compileExpression(infix.Right, nil)
-
-		var lhsSyms []*Symbol
-		lhsSyms, cond = c.handleComparisons(infix.Operator, left, right, info, cond)
-
-		c.requireCondLHSFrame()[key(c.FuncNameMangled, expr)] = lhsSyms
-		temps = append(temps, condTemp{infix.Left, left})
-		// Free right-side temporaries (only used for comparison).
-		// Left-side values are retained in condLHS for later substitution.
-		c.freeTemporary(infix.Right, right)
-		return cond, temps
+		return c.extractCondExprSelf(infix, info, cond, temps)
 	}
 
 	// Not a conditional expression — recurse into children
@@ -501,6 +487,21 @@ func (c *Compiler) extractCondExprs(expr ast.Expression, cond llvm.Value, temps
 	return cond, temps
 }
 
+func (c *Compiler) extractCondExprSelf(infix *ast.InfixExpression, info *ExprInfo, cond llvm.Value, temps []condTemp) (llvm.Value, []condTemp) {
+	left := c.compileExpression(infix.Left, nil)
+	right := c.compileExpression(infix.Right, nil)
+
+	var lhsSyms []*Symbol
+	lhsSyms, cond = c.handleComparisons(infix.Operator, left, right, info, cond)
+
+	c.requireCondLHSFrame()[key(c.FuncNameMangled, infix)] = lhsSyms
+	temps = append(temps, condTemp{infix.Left, left})
+	// Free right-side temporaries (only used for comparison).
+	// Left-side values are retained in condLHS for later substitution.
+	c.freeTemporary(infix.Right, right)
+	return cond, temps
+}
+
 // cleanupCondExprElse frees temporaries retained during cond-expr extraction
 // that are not consumed when the condition evaluates to false.
 func (c *Compiler) cleanupCondExprElse(temps []condTemp) {
@@ -530,7 +531,7 @@ func (c *Compiler) compileCondExprValue(expr ast.Expression, baseCond llvm.Value
 
 func (c *Compiler) compileCondExprValueInFrame(expr ast.Expression, baseCond llvm.Value, onTrue func()) {
 	if c.hasLogicalOrCondExprInTree(expr) {
-		c.compileCondExprAlternative(expr, baseCond, onTrue, func() {})
+		c.compileCondExprWithFailure(expr, baseCond, onTrue, func() {})
 		return
 	}
 
@@ -591,7 +592,7 @@ func (c *Compiler) compileCondExprChildrenInFrame(children []ast.Expression, bas
 	child := children[0]
 	rest := children[1:]
 	if c.hasCondExprInTree(child) {
-		c.compileCondExprAlternative(child, baseCond, func() {
+		c.compileCondExprWithFailure(child, baseCond, func() {
 			c.compileCondExprChildrenInFrame(rest, llvm.Value{}, onTrue, onFalse)
 		}, onFalse)
 		return
@@ -600,9 +601,9 @@ func (c *Compiler) compileCondExprChildrenInFrame(children []ast.Expression, bas
 	c.compileCondExprChildrenInFrame(rest, baseCond, onTrue, onFalse)
 }
 
-func (c *Compiler) compileCondExprAlternative(expr ast.Expression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+func (c *Compiler) compileCondExprWithFailure(expr ast.Expression, baseCond llvm.Value, onTrue func(), onFalse func()) {
 	if logicalOr, ok := c.logicalOrCondExpr(expr); ok {
-		c.compileLogicalOrCondExprAlternative(logicalOr, baseCond, onTrue, onFalse)
+		c.compileLogicalOrCondExprWithFailure(logicalOr, baseCond, onTrue, onFalse)
 		return
 	}
 
@@ -616,13 +617,7 @@ func (c *Compiler) compileCondExprAlternative(expr ast.Expression, baseCond llvm
 		if infix, ok := expr.(*ast.InfixExpression); ok {
 			info := c.ExprCache[key(c.FuncNameMangled, infix)]
 			if info != nil && info.HasCondScalar() && len(c.pendingLoopRanges(info.Ranges)) == 0 {
-				left := c.compileExpression(infix.Left, nil)
-				right := c.compileExpression(infix.Right, nil)
-
-				lhsSyms, cond := c.handleComparisons(infix.Operator, left, right, info, llvm.Value{})
-				c.requireCondLHSFrame()[key(c.FuncNameMangled, expr)] = lhsSyms
-				temps := []condTemp{{infix.Left, left}}
-				c.freeTemporary(infix.Right, right)
+				cond, temps := c.extractCondExprSelf(infix, info, llvm.Value{}, nil)
 				c.compileCondExprBranchWithFailure(cond, temps, onTrue, onFalse)
 				return
 			}
@@ -645,7 +640,14 @@ func (c *Compiler) withCondLHS(expr ast.Expression, syms []*Symbol, body func())
 	delete(frame, exprKey)
 }
 
-func (c *Compiler) compileLogicalOrCondExprAlternative(expr *ast.InfixExpression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+func (c *Compiler) compileLogicalOrCondExprWithFailure(expr *ast.InfixExpression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+	if !baseCond.IsNil() {
+		c.compileCondExprBranchWithFailure(baseCond, nil, func() {
+			c.compileLogicalOrCondExprWithFailure(expr, llvm.Value{}, onTrue, onFalse)
+		}, onFalse)
+		return
+	}
+
 	leftTrue := func() {
 		left := c.compileExpression(expr.Left, nil)
 		c.withCondLHS(expr, left, onTrue)
@@ -655,8 +657,8 @@ func (c *Compiler) compileLogicalOrCondExprAlternative(expr *ast.InfixExpression
 		c.withCondLHS(expr, right, onTrue)
 	}
 
-	c.compileCondExprAlternative(expr.Left, baseCond, leftTrue, func() {
-		c.compileCondExprAlternative(expr.Right, baseCond, rightTrue, onFalse)
+	c.compileCondExprWithFailure(expr.Left, llvm.Value{}, leftTrue, func() {
+		c.compileCondExprWithFailure(expr.Right, llvm.Value{}, rightTrue, onFalse)
 	})
 }
 

compiler/solver.go

@@ -1509,6 +1509,9 @@ func (ts *TypeSolver) typeLogicalOrExpression(expr *ast.InfixExpression, left, r
 	rightInfo := ts.ExprCache[key(ts.FuncNameMangled, expr.Right)]
 
 	if ts.InValueExpr {
+		// Value-position OR is asymmetric: the left operand must be able to
+		// fail, while the right operand may be another condition or a plain
+		// fallback value.
 		if leftInfo == nil || !leftInfo.HasCondExpr() {
 			ts.Errors = append(ts.Errors, &token.CompileError{
 				Token: expr.Token,

tests/cond/value_cond_expr.exp

@@ -66,6 +66,9 @@ LogicalOrBeforeExisting: 44
 LogicalOrExistingFalse: 44
 LogicalOrNestedAdd: 8
 LogicalOrCallArg: 14
+LogicalOrHeapFallback: fallback
+LogicalOrPairFallback: 7 8
+LogicalOrNestedSum: 10
 LogicalOrDefault: -1
 LogicalOrDefaultArg: -2
 LogicalOrArrayDefault: [-1 -1 -1 3 4 5 6 7 -1 -1]

tests/cond/value_cond_expr.spt

@@ -270,6 +270,15 @@ lorNestedAdd = (b > 2 || d < 10) + 1
 lorCallArg = Double(b > 2 || d < 10)
 "LogicalOrCallArg: -lorCallArg"
 
+lorHeapFallback = (sl ⊕ sm) > "hello x" || "fallback"
+"LogicalOrHeapFallback: -lorHeapFallback"
+
+lorPairA, lorPairB = Pair(1, 2) > Pair(5, 5) || Pair(7, 8)
+"LogicalOrPairFallback: -lorPairA -lorPairB"
+
+lorNestedSum = (b > 2 || d < 10) + (a > 10 || c > 2)
+"LogicalOrNestedSum: -lorNestedSum"
+
 lorDefault = b > 2 || -1
 "LogicalOrDefault: -lorDefault"