Function optimizeAndNode

pkg/workflow/expression_optimizer.go:209–315

--- node-specific optimisers ------------------------------------------------

(n *AndNode)

// --- node-specific optimisers ------------------------------------------------

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

	// Annihilation: A && false → false  (before flattening for early exit).
	if isBoolLiteral(left, false) || isBoolLiteral(right, false) {
		expressionOptimizerLog.Printf("AND annihilation: %s && %s → false", left.Render(), right.Render())
		return &BooleanLiteralNode{Value: false}
	}

	// Flatten the entire AND chain so that rules can operate across nesting levels.
	// e.g. A && (A && B) → [A, A, B] → dedup → [A, B] → A && B
	terms := collectAndTerms(&AndNode{Left: left, Right: right})

	// Annihilation within the flat list (covers cases after child optimisation).
	for _, t := range terms {
		if isBoolLiteral(t, false) {
			expressionOptimizerLog.Printf("AND annihilation (flatten): false term → false")
			return &BooleanLiteralNode{Value: false}
		}
	}

	// Identity: filter out `true` literals, but keep them when any term is a
	// status function (to preserve status-function semantics).
	hasStatusFuncInTerms := slices.ContainsFunc(terms, containsStatusFunc)
	filtered := make([]ConditionNode, 0, len(terms))
	for _, t := range terms {
		if isBoolLiteral(t, true) && !hasStatusFuncInTerms {
			expressionOptimizerLog.Printf("AND identity (flatten): removed true literal")
			continue
		}
		filtered = append(filtered, t)
	}
	if len(filtered) == 0 {
		return &BooleanLiteralNode{Value: true}
	}

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

	// Complement: A && !A → false (skip when status functions present).
	if !hasStatusFuncInTerms {
		for i := range deduped {
			for j := i + 1; j < len(deduped); j++ {