feat(language): add logical or support

Add || parsing and typing for statement conditions and value-position conditional expressions. In value position, logical OR now preserves Pluto's conditional value semantics by returning the first admitted value and supporting plain fallback values when the left condition fails.

Covers parser behavior, bitwise OR non-regression, scalar/function-argument fallback, ranged array fallback, and ranged condition gates in E2E tests.

Author: thiremani

compiler/cond.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/thiremani/pluto/ast"
+	"github.com/thiremani/pluto/token"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -401,10 +402,10 @@ func (c *Compiler) valuesHaveCondExpr(values []ast.Expression) bool {
 }
 
 // hasCondExprInTree returns true if any node in the expression tree has
-// CondScalar set (a scalar comparison in value position).
+// conditional value lowering.
 func (c *Compiler) hasCondExprInTree(expr ast.Expression) bool {
 	info := c.ExprCache[key(c.FuncNameMangled, expr)]
-	if info != nil && info.HasCondScalar() {
+	if info != nil && info.HasCondExpr() {
 		return true
 	}
 	for _, child := range ast.ExprChildren(expr) {
@@ -415,6 +416,28 @@ func (c *Compiler) hasCondExprInTree(expr ast.Expression) bool {
 	return false
 }
 
+func (c *Compiler) logicalOrCondExpr(expr ast.Expression) (*ast.InfixExpression, bool) {
+	infix, ok := expr.(*ast.InfixExpression)
+	if !ok || infix.Operator != token.SYM_LOGICAL_OR {
+		return nil, false
+	}
+
+	info := c.ExprCache[key(c.FuncNameMangled, expr)]
+	return infix, info != nil && info.HasCondOr()
+}
+
+func (c *Compiler) hasLogicalOrCondExprInTree(expr ast.Expression) bool {
+	if _, ok := c.logicalOrCondExpr(expr); ok {
+		return true
+	}
+	for _, child := range ast.ExprChildren(expr) {
+		if c.hasLogicalOrCondExprInTree(child) {
+			return true
+		}
+	}
+	return false
+}
+
 // handleComparisons processes each slot of a multi-return comparison based on
 // its CondMode. CondScalar slots are compared and ANDed into cond. CondArray
 // slots are compiled as array filters (source freed, marked borrowed).
@@ -494,13 +517,23 @@ func (c *Compiler) cleanupCondExprElse(temps []condTemp) {
 	}
 }
 
-// compileCondExprValue extracts cond-expr predicates for expr, branches on the
-// combined condition (AND with baseCond when provided), and compiles onTrue on
-// the true path only. False path performs standard cond-expr cleanup.
+// compileCondExprValue extracts cond-expr predicates for expr, branches through
+// value-position conditions, and compiles onTrue on admitted paths only. Plain
+// comparisons compose as AND; value-position logical OR tries the left operand
+// first and falls back to the right operand only on the left false path.
 func (c *Compiler) compileCondExprValue(expr ast.Expression, baseCond llvm.Value, onTrue func()) {
 	c.pushCondLHSFrame()
 	defer c.popCondLHSFrame()
 
+	c.compileCondExprValueInFrame(expr, baseCond, onTrue)
+}
+
+func (c *Compiler) compileCondExprValueInFrame(expr ast.Expression, baseCond llvm.Value, onTrue func()) {
+	if c.hasLogicalOrCondExprInTree(expr) {
+		c.compileCondExprAlternative(expr, baseCond, onTrue, func() {})
+		return
+	}
+
 	cond, temps := c.extractCondExprs(expr, baseCond, nil)
 	c.compileCondExprBranch(cond, temps, onTrue)
 }
@@ -512,6 +545,11 @@ func (c *Compiler) compileOperandCondExprValue(expr ast.Expression, baseCond llv
 	c.pushCondLHSFrame()
 	defer c.popCondLHSFrame()
 
+	if c.hasLogicalOrCondExprInTree(expr) {
+		c.compileCondExprChildrenInFrame(ast.ExprChildren(expr), baseCond, onTrue, func() {})
+		return
+	}
+
 	cond := baseCond
 	var temps []condTemp
 	for _, child := range ast.ExprChildren(expr) {
@@ -521,6 +559,10 @@ func (c *Compiler) compileOperandCondExprValue(expr ast.Expression, baseCond llv
 }
 
 func (c *Compiler) compileCondExprBranch(cond llvm.Value, temps []condTemp, onTrue func()) {
+	c.compileCondExprBranchWithFailure(cond, temps, onTrue, func() {})
+}
+
+func (c *Compiler) compileCondExprBranchWithFailure(cond llvm.Value, temps []condTemp, onTrue func(), onFalse func()) {
 	if cond.IsNil() {
 		onTrue()
 		return
@@ -534,11 +576,90 @@ func (c *Compiler) compileCondExprBranch(cond llvm.Value, temps []condTemp, onTr
 
 	c.builder.SetInsertPointAtEnd(elseBlock)
 	c.cleanupCondExprElse(temps)
+	onFalse()
 	c.builder.CreateBr(contBlock)
 
 	c.builder.SetInsertPointAtEnd(contBlock)
 }
 
+func (c *Compiler) compileCondExprChildrenInFrame(children []ast.Expression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+	if len(children) == 0 {
+		c.compileCondExprBranchWithFailure(baseCond, nil, onTrue, onFalse)
+		return
+	}
+
+	child := children[0]
+	rest := children[1:]
+	if c.hasCondExprInTree(child) {
+		c.compileCondExprAlternative(child, baseCond, func() {
+			c.compileCondExprChildrenInFrame(rest, llvm.Value{}, onTrue, onFalse)
+		}, onFalse)
+		return
+	}
+
+	c.compileCondExprChildrenInFrame(rest, baseCond, onTrue, onFalse)
+}
+
+func (c *Compiler) compileCondExprAlternative(expr ast.Expression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+	if logicalOr, ok := c.logicalOrCondExpr(expr); ok {
+		c.compileLogicalOrCondExprAlternative(logicalOr, baseCond, onTrue, onFalse)
+		return
+	}
+
+	if !c.hasLogicalOrCondExprInTree(expr) {
+		cond, temps := c.extractCondExprs(expr, baseCond, nil)
+		c.compileCondExprBranchWithFailure(cond, temps, onTrue, onFalse)
+		return
+	}
+
+	c.compileCondExprChildrenInFrame(ast.ExprChildren(expr), baseCond, func() {
+		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)
+				c.compileCondExprBranchWithFailure(cond, temps, onTrue, onFalse)
+				return
+			}
+		}
+
+		onTrue()
+	}, onFalse)
+}
+
+func (c *Compiler) withCondLHS(expr ast.Expression, syms []*Symbol, body func()) {
+	frame := c.requireCondLHSFrame()
+	exprKey := key(c.FuncNameMangled, expr)
+	old, hadOld := frame[exprKey]
+	frame[exprKey] = syms
+	body()
+	if hadOld {
+		frame[exprKey] = old
+		return
+	}
+	delete(frame, exprKey)
+}
+
+func (c *Compiler) compileLogicalOrCondExprAlternative(expr *ast.InfixExpression, baseCond llvm.Value, onTrue func(), onFalse func()) {
+	leftTrue := func() {
+		left := c.compileExpression(expr.Left, nil)
+		c.withCondLHS(expr, left, onTrue)
+	}
+	rightTrue := func() {
+		right := c.compileExpression(expr.Right, nil)
+		c.withCondLHS(expr, right, onTrue)
+	}
+
+	c.compileCondExprAlternative(expr.Left, baseCond, leftTrue, func() {
+		c.compileCondExprAlternative(expr.Right, baseCond, rightTrue, onFalse)
+	})
+}
+
 func (c *Compiler) isRangeDriverCond(expr ast.Expression) bool {
 	info := c.ExprCache[key(c.FuncNameMangled, expr)]
 	if len(info.OutTypes) != 1 {

compiler/operators.go

@@ -650,6 +650,18 @@ var defaultOps = map[opKey]opFunc{
 		return
 	},
 
+	// Logical OR
+	{Operator: token.SYM_LOGICAL_OR, LeftType: I1, RightType: I1}: func(c *Compiler, left, right *Symbol, compile bool) (s *Symbol) {
+		s = &Symbol{}
+		s.Type = left.Type
+		if !compile {
+			return
+		}
+
+		s.Val = c.builder.CreateOr(left.Val, right.Val, "or_cond")
+		return
+	},
+
 	// Bitwise XOR
 	{Operator: token.SYM_XOR, LeftType: I64, RightType: I64}: func(c *Compiler, left, right *Symbol, compile bool) (s *Symbol) {
 		s = &Symbol{}

compiler/solver.go

@@ -22,6 +22,7 @@ const (
 	CondNone   CondMode = iota // Normal expression (not a comparison in value position)
 	CondScalar                 // Scalar: extract LHS value, branch on condition
 	CondArray                  // Array: element-wise filter, keep LHS where condition holds
+	CondOr                     // Logical OR in value position: first true operand wins
 )
 
 type ExprInfo struct {
@@ -47,6 +48,24 @@ func (info *ExprInfo) HasCondScalar() bool {
 	return false
 }
 
+func (info *ExprInfo) HasCondOr() bool {
+	for _, m := range info.CompareModes {
+		if m == CondOr {
+			return true
+		}
+	}
+	return false
+}
+
+func (info *ExprInfo) HasCondExpr() bool {
+	for _, m := range info.CompareModes {
+		if m == CondScalar || m == CondOr {
+			return true
+		}
+	}
+	return false
+}
+
 // ExprKey is the key for ExprCache, combining function context with expression.
 // FuncNameMangled is the mangled function name ("" for script-level expressions).
 type ExprKey struct {
@@ -1454,6 +1473,89 @@ func (ts *TypeSolver) typeInfixSlot(expr *ast.InfixExpression, leftType, rightTy
 	return resultType, CondNone
 }
 
+func (ts *TypeSolver) logicalOrValueType(leftType, rightType Type, tok token.Token) Type {
+	if ptr, ok := leftType.(Ptr); ok {
+		leftType = ptr.Elem
+	}
+	if ptr, ok := rightType.(Ptr); ok {
+		rightType = ptr.Elem
+	}
+
+	switch {
+	case leftType.Kind() == UnresolvedKind:
+		return rightType
+	case rightType.Kind() == UnresolvedKind:
+		return leftType
+	case leftType.Kind() == StrKind && rightType.Kind() == StrKind:
+		return mergeStringFlavor(leftType, rightType)
+	case TypeEqual(leftType, rightType):
+		return leftType
+	default:
+		ts.Errors = append(ts.Errors, &token.CompileError{
+			Token: tok,
+			Msg:   fmt.Sprintf("logical OR value operands must have matching output types, got %s and %s", leftType, rightType),
+		})
+		return Unresolved{}
+	}
+}
+
+func isI1(t Type) bool {
+	intType, ok := t.(Int)
+	return ok && intType.Width == 1
+}
+
+func (ts *TypeSolver) typeLogicalOrExpression(expr *ast.InfixExpression, left, right []Type) []Type {
+	leftInfo := ts.ExprCache[key(ts.FuncNameMangled, expr.Left)]
+	rightInfo := ts.ExprCache[key(ts.FuncNameMangled, expr.Right)]
+
+	if ts.InValueExpr {
+		if leftInfo == nil || !leftInfo.HasCondExpr() {
+			ts.Errors = append(ts.Errors, &token.CompileError{
+				Token: expr.Token,
+				Msg:   "logical OR in value position requires a conditional left operand",
+			})
+		}
+
+		types := make([]Type, len(left))
+		compareModes := make([]CondMode, len(left))
+		for i := range left {
+			types[i] = ts.logicalOrValueType(left[i], right[i], expr.Token)
+			compareModes[i] = CondOr
+		}
+
+		ts.ExprCache[key(ts.FuncNameMangled, expr)] = &ExprInfo{
+			OutTypes:     types,
+			ExprLen:      len(types),
+			HasRanges:    (leftInfo != nil && leftInfo.HasRanges) || (rightInfo != nil && rightInfo.HasRanges),
+			CompareModes: compareModes,
+		}
+		return types
+	}
+
+	types := []Type{I1}
+	if len(left) != 1 {
+		ts.Errors = append(ts.Errors, &token.CompileError{
+			Token: expr.Token,
+			Msg:   fmt.Sprintf("logical OR condition operands must produce a single value, got %d", len(left)),
+		})
+		types = []Type{Unresolved{}}
+	} else if left[0].Kind() != UnresolvedKind && right[0].Kind() != UnresolvedKind && (!isI1(left[0]) || !isI1(right[0])) {
+		ts.Errors = append(ts.Errors, &token.CompileError{
+			Token: expr.Token,
+			Msg:   fmt.Sprintf("logical OR requires condition operands, got %s and %s", left[0], right[0]),
+		})
+		types = []Type{Unresolved{}}
+	}
+
+	ts.ExprCache[key(ts.FuncNameMangled, expr)] = &ExprInfo{
+		OutTypes:     types,
+		ExprLen:      len(types),
+		HasRanges:    (leftInfo != nil && leftInfo.HasRanges) || (rightInfo != nil && rightInfo.HasRanges),
+		CompareModes: make([]CondMode, len(types)),
+	}
+	return types
+}
+
 // TypeInfixExpression returns output types of infix expression
 // If either left or right operands are pointers, it will dereference them
 // This is because pointers are automatically dereferenced
@@ -1471,6 +1573,10 @@ func (ts *TypeSolver) TypeInfixExpression(expr *ast.InfixExpression) (types []Ty
 		return
 	}
 
+	if expr.Operator == token.SYM_LOGICAL_OR {
+		return ts.typeLogicalOrExpression(expr, left, right)
+	}
+
 	isValueCmp := ts.InValueExpr && expr.Token.IsComparison()
 	types = make([]Type, len(left))
 	compareModes := make([]CondMode, len(left))