Function constantCallMatcher

cel/folding.go:577–640

constantCallMatcher identifies strict and non-strict calls which can be folded.

(e ast.NavigableExpr)

// constantCallMatcher identifies strict and non-strict calls which can be folded.
func constantCallMatcher(e ast.NavigableExpr) bool {
	call := e.AsCall()
	children := e.Children()
	fnName := call.FunctionName()
	if fnName == operators.LogicalAnd {
		for _, child := range children {
			if child.Kind() == ast.LiteralKind {
				return true
			}
		}
	}
	if fnName == operators.LogicalOr {
		for _, child := range children {
			if child.Kind() == ast.LiteralKind {
				return true
			}
		}
	}
	if fnName == operators.Conditional {
		cond := children[0]
		if cond.Kind() == ast.LiteralKind && cond.AsLiteral().Type() == types.BoolType {
			return true
		}
	}
	if fnName == operators.Equals || fnName == operators.NotEquals {
		if hasComprehensionVar(e) {
			return false
		}
		if isExprConstantOfKind(children[0], types.BoolType) || isExprConstantOfKind(children[1], types.BoolType) {
			return true
		}
	}
	if fnName == operators.In {
		if hasComprehensionVar(e) {
			return false
		}
		haystack := children[1]
		if haystack.Kind() == ast.ListKind && haystack.AsList().Size() == 0 {
			return true
		}
		needle := children[0]
		if (needle.Kind() == ast.LiteralKind || isSelfEqualIdent(needle)) && haystack.Kind() == ast.ListKind {
			needleIsLit := needle.Kind() == ast.LiteralKind
			needleLitVal := needle.AsLiteral()
			needleIdentVal := needle.AsIdent()
			list := haystack.AsList()
			for _, elem := range list.Elements() {
				if needleIsLit && elem.Kind() == ast.LiteralKind && elem.AsLiteral().Equal(needleLitVal) == types.True {
					return true
				}
				if !needleIsLit && elem.Kind() == ast.IdentKind && elem.AsIdent() == needleIdentVal {
					return true
				}
			}
		}
	}
	// convert all other calls with constant arguments
	for _, child := range children {