Bump cel-go to v0.12.0

vendor/github.com/google/cel-go/interpreter/planner.go

@@ -302,8 +302,18 @@ func (p *planner) planCall(expr *exprpb.Expr) (Interpretable, error) {
 	case 0:
 		return p.planCallZero(expr, fnName, oName, fnDef)
 	case 1:
+		// If the FunctionOp has been used, then use it as it may exist for the purposes
+		// of dynamic dispatch within a singleton function implementation.
+		if fnDef != nil && fnDef.Unary == nil && fnDef.Function != nil {
+			return p.planCallVarArgs(expr, fnName, oName, fnDef, args)
+		}
 		return p.planCallUnary(expr, fnName, oName, fnDef, args)
 	case 2:
+		// If the FunctionOp has been used, then use it as it may exist for the purposes
+		// of dynamic dispatch within a singleton function implementation.
+		if fnDef != nil && fnDef.Binary == nil && fnDef.Function != nil {
+			return p.planCallVarArgs(expr, fnName, oName, fnDef, args)
+		}
 		return p.planCallBinary(expr, fnName, oName, fnDef, args)
 	default:
 		return p.planCallVarArgs(expr, fnName, oName, fnDef, args)
@@ -334,20 +344,23 @@ func (p *planner) planCallUnary(expr *exprpb.Expr,
 	args []Interpretable) (Interpretable, error) {
 	var fn functions.UnaryOp
 	var trait int
+	var nonStrict bool
 	if impl != nil {
 		if impl.Unary == nil {
 			return nil, fmt.Errorf("no such overload: %s(arg)", function)
 		}
 		fn = impl.Unary
 		trait = impl.OperandTrait
+		nonStrict = impl.NonStrict
 	}
 	return &evalUnary{
-		id:       expr.Id,
-		function: function,
-		overload: overload,
-		arg:      args[0],
-		trait:    trait,
-		impl:     fn,
+		id:        expr.Id,
+		function:  function,
+		overload:  overload,
+		arg:       args[0],
+		trait:     trait,
+		impl:      fn,
+		nonStrict: nonStrict,
 	}, nil
 }
 
@@ -359,21 +372,24 @@ func (p *planner) planCallBinary(expr *exprpb.Expr,
 	args []Interpretable) (Interpretable, error) {
 	var fn functions.BinaryOp
 	var trait int
+	var nonStrict bool
 	if impl != nil {
 		if impl.Binary == nil {
 			return nil, fmt.Errorf("no such overload: %s(lhs, rhs)", function)
 		}
 		fn = impl.Binary
 		trait = impl.OperandTrait
+		nonStrict = impl.NonStrict
 	}
 	return &evalBinary{
-		id:       expr.Id,
-		function: function,
-		overload: overload,
-		lhs:      args[0],
-		rhs:      args[1],
-		trait:    trait,
-		impl:     fn,
+		id:        expr.Id,
+		function:  function,
+		overload:  overload,
+		lhs:       args[0],
+		rhs:       args[1],
+		trait:     trait,
+		impl:      fn,
+		nonStrict: nonStrict,
 	}, nil
 }
 
@@ -385,20 +401,23 @@ func (p *planner) planCallVarArgs(expr *exprpb.Expr,
 	args []Interpretable) (Interpretable, error) {
 	var fn functions.FunctionOp
 	var trait int
+	var nonStrict bool
 	if impl != nil {
 		if impl.Function == nil {
 			return nil, fmt.Errorf("no such overload: %s(...)", function)
 		}
 		fn = impl.Function
 		trait = impl.OperandTrait
+		nonStrict = impl.NonStrict
 	}
 	return &evalVarArgs{
-		id:       expr.Id,
-		function: function,
-		overload: overload,
-		args:     args,
-		trait:    trait,
-		impl:     fn,
+		id:        expr.Id,
+		function:  function,
+		overload:  overload,
+		args:      args,
+		trait:     trait,
+		impl:      fn,
+		nonStrict: nonStrict,
 	}, nil
 }