refactor(ast): centralize logical or detection

Add ast.IsLogicalOr and use it at AST-expression logical OR checks so compiler conditional lowering does not import token just to inspect operator spelling.

Author: thiremani

ast/ast.go

@@ -445,6 +445,15 @@ type InfixExpression struct {
 	Right    Expression
 }
 
+// IsLogicalOr returns exp as an infix logical OR expression.
+func IsLogicalOr(exp Expression) (*InfixExpression, bool) {
+	infix, ok := exp.(*InfixExpression)
+	if !ok || infix.Operator != token.SYM_LOGICAL_OR {
+		return nil, false
+	}
+	return infix, true
+}
+
 func (ie *InfixExpression) expressionNode()  {}
 func (ie *InfixExpression) Tok() token.Token { return ie.Token }
 func (ie *InfixExpression) String() string {

compiler/compiler.go

@@ -1705,7 +1705,7 @@ func (c *Compiler) compileCondScalar(op string, left *Symbol, right *Symbol) *Sy
 }
 
 func (c *Compiler) compileInfixBasic(expr *ast.InfixExpression, info *ExprInfo) (res []*Symbol) {
-	if expr.Operator == token.SYM_LOGICAL_OR && !info.HasFallbackOr() {
+	if _, isLogicalOr := ast.IsLogicalOr(expr); isLogicalOr && !info.HasFallbackOr() {
 		return c.compileLogicalOrCondition(expr)
 	}
 

compiler/cond.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/thiremani/pluto/ast"
-	"github.com/thiremani/pluto/token"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -417,8 +416,8 @@ func (c *Compiler) hasCondExprInTree(expr ast.Expression) bool {
 }
 
 func (c *Compiler) logicalOrCondExpr(expr ast.Expression) (*ast.InfixExpression, bool) {
-	infix, ok := expr.(*ast.InfixExpression)
-	if !ok || infix.Operator != token.SYM_LOGICAL_OR {
+	infix, ok := ast.IsLogicalOr(expr)
+	if !ok {
 		return nil, false
 	}
 

compiler/solver.go

@@ -1573,7 +1573,7 @@ func (ts *TypeSolver) TypeInfixExpression(expr *ast.InfixExpression) (types []Ty
 		return
 	}
 
-	if expr.Operator == token.SYM_LOGICAL_OR {
+	if _, isLogicalOr := ast.IsLogicalOr(expr); isLogicalOr {
 		return ts.typeLogicalOrExpression(expr, left, right)
 	}
 

parser/parser.go

@@ -791,7 +791,7 @@ func (p *StmtParser) isCondition(exp ast.Expression) bool {
 		return true
 	}
 
-	if infix, ok := exp.(*ast.InfixExpression); ok && infix.Operator == token.SYM_LOGICAL_OR {
+	if infix, ok := ast.IsLogicalOr(exp); ok {
 		return p.isCondition(infix.Left) && p.isCondition(infix.Right)
 	}