Function optimizeDisjunctionNode

pkg/workflow/expression_optimizer.go:445–541

(n *DisjunctionNode)

}

func optimizeDisjunctionNode(n *DisjunctionNode) ConditionNode {
	if len(n.Terms) == 0 {
		return n
	}

	// Bottom-up: optimise each term first.
	optimised := make([]ConditionNode, 0, len(n.Terms))
	for _, term := range n.Terms {
		optimised = append(optimised, optimizeNode(term))
	}

	// Short-circuit: if any term is true the whole disjunction is true.
	for _, term := range optimised {
		if isBoolLiteral(term, true) {
			expressionOptimizerLog.Printf("Disjunction short-circuit on true")
			return &BooleanLiteralNode{Value: true}
		}
	}

	// Filter out false terms (identity: A || false → A).
	filtered := make([]ConditionNode, 0, len(optimised))
	for _, term := range optimised {
		if !isBoolLiteral(term, false) {
			filtered = append(filtered, term)
		}
	}
	if len(filtered) == 0 {
		expressionOptimizerLog.Printf("Disjunction all-false → false")
		return &BooleanLiteralNode{Value: false}
	}

	// Deduplicate terms by rendered form.
	seen := make(map[string]struct{}, len(filtered))
	deduped := make([]ConditionNode, 0, len(filtered))
	for _, term := range filtered {
		key := term.Render()
		if _, exists := seen[key]; !exists {
			seen[key] = struct{}{}
			deduped = append(deduped, term)
		} else {
			expressionOptimizerLog.Printf("Disjunction dedup: removing duplicate term %q", key)
		}
	}

	if len(deduped) == 1 {
		return deduped[0]
	}

	// Complement: A || !A → true (mirrors the OrNode complement rule).
	// Guard: skip when any term contains a status function so that
	// status-function expressions are never silently eliminated.
	if !slices.ContainsFunc(deduped, containsStatusFunc) {
		for i := range deduped {
			for j := i + 1; j < len(deduped); j++ {
				if isNegationOf(deduped[i], deduped[j]) {
					expressionOptimizerLog.Printf("Disjunction complement: %s || %s → true", deduped[i].Render(), deduped[j].Render())
					return &BooleanLiteralNode{Value: true}
				}