Function optimizeOrNode

pkg/workflow/expression_optimizer.go:317–381

(n *OrNode)

}

func optimizeOrNode(n *OrNode) ConditionNode {
	// Bottom-up: optimise children first.
	left := optimizeNode(n.Left)
	right := optimizeNode(n.Right)

	// Flatten OR chains: when either child is already an OrNode or DisjunctionNode,
	// collect all terms and delegate to the DisjunctionNode optimiser, which
	// performs dedup, false-filtering and true short-circuit across the whole chain.
	_, leftIsOr := left.(*OrNode)
	_, leftIsDisj := left.(*DisjunctionNode)
	_, rightIsOr := right.(*OrNode)
	_, rightIsDisj := right.(*DisjunctionNode)
	if leftIsOr || leftIsDisj || rightIsOr || rightIsDisj {
		terms := append(collectOrTerms(left), collectOrTerms(right)...)
		expressionOptimizerLog.Printf("OR flatten: collected %d terms", len(terms))
		return optimizeDisjunctionNode(&DisjunctionNode{Terms: terms})
	}

	// Annihilation: A || true → true
	if isBoolLiteral(left, true) || isBoolLiteral(right, true) {
		expressionOptimizerLog.Printf("OR annihilation: %s || %s → true", left.Render(), right.Render())
		return &BooleanLiteralNode{Value: true}
	}

	// Identity: A || false → A
	if isBoolLiteral(right, false) {
		expressionOptimizerLog.Printf("OR identity (right false): %s || false → %s", left.Render(), left.Render())
		return left
	}
	if isBoolLiteral(left, false) {
		expressionOptimizerLog.Printf("OR identity (left false): false || %s → %s", right.Render(), right.Render())
		return right
	}

	// Skip idempotent / complement rules when status functions are present.
	if containsStatusFunc(left) || containsStatusFunc(right) {
		return &OrNode{Left: left, Right: right}
	}

	// Idempotent: A || A → A
	if nodesEqual(left, right) {
		expressionOptimizerLog.Printf("OR idempotent: %s || %s → %s", left.Render(), right.Render(), left.Render())
		return left
	}

	// Complement: A || !A → true
	if isNegationOf(left, right) {
		expressionOptimizerLog.Printf("OR complement: %s || %s → true", left.Render(), right.Render())
		return &BooleanLiteralNode{Value: true}
	}

	// Absorption (OR): A || (A && B) → A
	// If one side is an AND-chain that contains the other side as a conjunct,
	// the AND-chain is absorbed by the simpler operand.
	for _, pair := range [][2]ConditionNode{{left, right}, {right, left}} {
		simple, complex := pair[0], pair[1]
		if termSubsumedBy(complex, simple) {
			expressionOptimizerLog.Printf("OR absorption: %s || (%s) → %s (absorbed)",