Merge branch 'master' into vanity-cel-go-import

Author: dmitriplotnikov

MODULE.bazel

@@ -37,16 +37,20 @@ bazel_dep(
 bazel_dep(name = "rules_shell", version = "0.6.1")
 bazel_dep(name = "rules_license", version = "1.0.0")
 
-
 # local_path_override(
 #     module_name = "cel-spec",
 #     path = "../cel-spec",
 # )
 bazel_dep(
     name = "cel-spec",
-    version = "0.25.1",
+    version = "0.25.2",
     repo_name = "dev_cel_expr",
 )
+git_override(
+    module_name = "cel-spec",
+    commit = "ba58ae5007845f3a1279b488cdeb79645ce958bb",
+    remote = "https://github.com/cel-expr/cel-spec",
+)
 
 go_sdk = use_extension("@io_bazel_rules_go//go:extensions.bzl", "go_sdk")
 go_sdk.download(version = "1.23.0")

cel/cel_test.go

@@ -1683,6 +1683,64 @@ func TestVariadicLogicalOperators(t *testing.T) {
 	}
 }
 
+func TestCostTrackingWithStateTracking(t *testing.T) {
+	// Cost tracking and state tracking install separate observers. Every observer has to see
+	// every evaluation step, whichever combination of them is configured.
+	env := testEnv(t, Variable("a", StringType))
+	ast, iss := env.Compile(`a.startsWith("x") && a.contains("yz")`)
+	if iss.Err() != nil {
+		t.Fatalf("env.Compile() failed: %v", iss.Err())
+	}
+	baseline, _ := evalCostAndState(t, env, ast, CostTracking(nil))
+	if baseline == 0 {
+		t.Fatalf("cost tracking alone reported a cost of 0")
+	}
+	tests := []struct {
+		name       string
+		opts       []ProgramOption
+		wantState  bool
+		wantEqCost bool
+	}{
+		{name: "cost", opts: []ProgramOption{CostTracking(nil)}, wantEqCost: true},
+		{name: "cost and state", opts: []ProgramOption{CostTracking(nil), EvalOptions(OptTrackState)},
+			wantState: true, wantEqCost: true},
+		{name: "cost and exhaustive", opts: []ProgramOption{CostTracking(nil), EvalOptions(OptExhaustiveEval)},
+			wantState: true, wantEqCost: true},
+	}
+	for _, tst := range tests {
+		tc := tst
+		t.Run(tc.name, func(t *testing.T) {
+			cost, hasState := evalCostAndState(t, env, ast, tc.opts...)
+			if tc.wantEqCost && cost != baseline {
+				t.Errorf("actual cost got %d, wanted %d", cost, baseline)
+			}
+			if hasState != tc.wantState {
+				t.Errorf("state tracked got %t, wanted %t", hasState, tc.wantState)
+			}
+		})
+	}
+}
+
+// evalCostAndState evaluates the ast and reports the tracked cost along with whether evaluation
+// state was recorded.
+func evalCostAndState(t *testing.T, env *Env, ast *Ast, opts ...ProgramOption) (uint64, bool) {
+	t.Helper()
+	prg, err := env.Program(ast, opts...)
+	if err != nil {
+		t.Fatalf("env.Program() failed: %v", err)
+	}
+	_, det, err := prg.Eval(map[string]any{"a": "xyz-abcdefghij"})
+	if err != nil {
+		t.Fatalf("prg.Eval() failed: %v", err)
+	}
+	cost := det.ActualCost()
+	if cost == nil {
+		t.Fatalf("det.ActualCost() returned nil")
+	}
+	state := det.State()
+	return *cost, state != nil && len(state.IDs()) != 0
+}
+
 func TestParseError(t *testing.T) {
 	env := testEnv(t)
 	_, iss := env.Parse("invalid & logical_and")

checker/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//common:go_default_library",
         "//common/ast:go_default_library",
         "//common/containers:go_default_library",
+        "//common/cost:go_default_library",
         "//common/debug:go_default_library",
         "//common/decls:go_default_library",
         "//common/operators:go_default_library",

checker/cost.go

@@ -19,6 +19,7 @@ import (
 
 	"cel.dev/cel-go/common"
 	"cel.dev/cel-go/common/ast"
+	"cel.dev/cel-go/common/cost"
 	"cel.dev/cel-go/common/overloads"
 	"cel.dev/cel-go/common/types"
 	"cel.dev/cel-go/parser"
@@ -115,35 +116,35 @@ func FixedSizeEstimate(size uint64) SizeEstimate {
 // If add would result in an uint64 overflow, the result is math.MaxUint64.
 func (se SizeEstimate) Add(sizeEstimate SizeEstimate) SizeEstimate {
 	return SizeEstimate{
-		addUint64NoOverflow(se.Min, sizeEstimate.Min),
-		addUint64NoOverflow(se.Max, sizeEstimate.Max),
+		cost.SafeAdd(se.Min, sizeEstimate.Min),
+		cost.SafeAdd(se.Max, sizeEstimate.Max),
 	}
 }
 
 // Multiply multiplies by another SizeEstimate and returns the product.
 // If multiply would result in an uint64 overflow, the result is math.MaxUint64.
 func (se SizeEstimate) Multiply(sizeEstimate SizeEstimate) SizeEstimate {
 	return SizeEstimate{
-		multiplyUint64NoOverflow(se.Min, sizeEstimate.Min),
-		multiplyUint64NoOverflow(se.Max, sizeEstimate.Max),
+		cost.SafeMultiply(se.Min, sizeEstimate.Min),
+		cost.SafeMultiply(se.Max, sizeEstimate.Max),
 	}
 }
 
 // MultiplyByCostFactor multiplies a SizeEstimate by a cost factor and returns the CostEstimate with the
 // nearest integer of the result, rounded up.
 func (se SizeEstimate) MultiplyByCostFactor(costPerUnit float64) CostEstimate {
 	return CostEstimate{
-		multiplyByCostFactor(se.Min, costPerUnit),
-		multiplyByCostFactor(se.Max, costPerUnit),
+		cost.SafeMultiplyByFactor(se.Min, costPerUnit),
+		cost.SafeMultiplyByFactor(se.Max, costPerUnit),
 	}
 }
 
 // MultiplyByCost multiplies by the cost and returns the product.
 // If multiply would result in an uint64 overflow, the result is math.MaxUint64.
-func (se SizeEstimate) MultiplyByCost(cost CostEstimate) CostEstimate {
+func (se SizeEstimate) MultiplyByCost(estimate CostEstimate) CostEstimate {
 	return CostEstimate{
-		multiplyUint64NoOverflow(se.Min, cost.Min),
-		multiplyUint64NoOverflow(se.Max, cost.Max),
+		cost.SafeMultiply(se.Min, estimate.Min),
+		cost.SafeMultiply(se.Max, estimate.Max),
 	}
 }
 
@@ -176,34 +177,34 @@ func UnknownCostEstimate() CostEstimate {
 }
 
 // FixedCostEstimate returns a cost with a fixed min and max range.
-func FixedCostEstimate(cost uint64) CostEstimate {
-	return CostEstimate{Min: cost, Max: cost}
+func FixedCostEstimate(fixedCost uint64) CostEstimate {
+	return CostEstimate{Min: fixedCost, Max: fixedCost}
 }
 
 // Add adds the costs and returns the sum.
 // If add would result in an uint64 overflow for the min or max, the value is set to math.MaxUint64.
-func (ce CostEstimate) Add(cost CostEstimate) CostEstimate {
+func (ce CostEstimate) Add(estimate CostEstimate) CostEstimate {
 	return CostEstimate{
-		Min: addUint64NoOverflow(ce.Min, cost.Min),
-		Max: addUint64NoOverflow(ce.Max, cost.Max),
+		Min: cost.SafeAdd(ce.Min, estimate.Min),
+		Max: cost.SafeAdd(ce.Max, estimate.Max),
 	}
 }
 
 // Multiply multiplies by the cost and returns the product.
 // If multiply would result in an uint64 overflow, the result is math.MaxUint64.
-func (ce CostEstimate) Multiply(cost CostEstimate) CostEstimate {
+func (ce CostEstimate) Multiply(estimate CostEstimate) CostEstimate {
 	return CostEstimate{
-		Min: multiplyUint64NoOverflow(ce.Min, cost.Min),
-		Max: multiplyUint64NoOverflow(ce.Max, cost.Max),
+		Min: cost.SafeMultiply(ce.Min, estimate.Min),
+		Max: cost.SafeMultiply(ce.Max, estimate.Max),
 	}
 }
 
 // MultiplyByCostFactor multiplies a CostEstimate by a cost factor and returns the CostEstimate with the
 // nearest integer of the result, rounded up.
 func (ce CostEstimate) MultiplyByCostFactor(costPerUnit float64) CostEstimate {
 	return CostEstimate{
-		Min: multiplyByCostFactor(ce.Min, costPerUnit),
-		Max: multiplyByCostFactor(ce.Max, costPerUnit),
+		Min: cost.SafeMultiplyByFactor(ce.Min, costPerUnit),
+		Max: cost.SafeMultiplyByFactor(ce.Max, costPerUnit),
 	}
 }
 
@@ -219,37 +220,6 @@ func (ce CostEstimate) Union(size CostEstimate) CostEstimate {
 	return result
 }
 
-// addUint64NoOverflow adds non-negative ints. If the result is exceeds math.MaxUint64, math.MaxUint64
-// is returned.
-func addUint64NoOverflow(x, y uint64) uint64 {
-	if y > 0 && x > math.MaxUint64-y {
-		return math.MaxUint64
-	}
-	return x + y
-}
-
-// multiplyUint64NoOverflow multiplies non-negative ints. If the result is exceeds math.MaxUint64, math.MaxUint64
-// is returned.
-func multiplyUint64NoOverflow(x, y uint64) uint64 {
-	if y != 0 && x > math.MaxUint64/y {
-		return math.MaxUint64
-	}
-	return x * y
-}
-
-// multiplyByFactor multiplies an integer by a cost factor float and returns the nearest integer value, rounded up.
-func multiplyByCostFactor(x uint64, y float64) uint64 {
-	xFloat := float64(x)
-	if xFloat > 0 && y > 0 && xFloat > math.MaxUint64/y {
-		return math.MaxUint64
-	}
-	ceil := math.Ceil(xFloat * y)
-	if ceil >= doubleTwoTo64 {
-		return math.MaxUint64
-	}
-	return uint64(ceil)
-}
-
 // CostOption configures flags which affect cost computations.
 type CostOption func(*coster) error
 
@@ -465,32 +435,32 @@ func (c *coster) cost(e ast.Expr) CostEstimate {
 	if e == nil {
 		return CostEstimate{}
 	}
-	var cost CostEstimate
+	var estimate CostEstimate
 	switch e.Kind() {
 	case ast.LiteralKind:
-		cost = constCost
+		estimate = constCost
 	case ast.IdentKind:
-		cost = c.costIdent(e)
+		estimate = c.costIdent(e)
 	case ast.SelectKind:
-		cost = c.costSelect(e)
+		estimate = c.costSelect(e)
 	case ast.CallKind:
-		cost = c.costCall(e)
+		estimate = c.costCall(e)
 	case ast.ListKind:
-		cost = c.costCreateList(e)
+		estimate = c.costCreateList(e)
 	case ast.MapKind:
-		cost = c.costCreateMap(e)
+		estimate = c.costCreateMap(e)
 	case ast.StructKind:
-		cost = c.costCreateStruct(e)
+		estimate = c.costCreateStruct(e)
 	case ast.ComprehensionKind:
 		if c.isBind(e) {
-			cost = c.costBind(e)
+			estimate = c.costBind(e)
 		} else {
-			cost = c.costComprehension(e)
+			estimate = c.costComprehension(e)
 		}
 	default:
 		return CostEstimate{}
 	}
-	return cost
+	return estimate
 }
 
 func (c *coster) costIdent(e ast.Expr) CostEstimate {
@@ -1013,14 +983,14 @@ func computeExprSize(expr ast.Expr) *SizeEstimate {
 	default:
 		return nil
 	}
-	cost := FixedSizeEstimate(v)
-	return &cost
+	size := FixedSizeEstimate(v)
+	return &size
 }
 
 func computeTypeSize(t *types.Type) *SizeEstimate {
 	if isScalar(t) {
-		cost := FixedSizeEstimate(1)
-		return &cost
+		size := FixedSizeEstimate(1)
+		return &size
 	}
 	return nil
 }
@@ -1041,8 +1011,6 @@ func isScalar(t *types.Type) bool {
 }
 
 var (
-	doubleTwoTo64 = math.Ldexp(1.0, 64)
-
 	unknownSizeEstimate = SizeEstimate{Min: 0, Max: math.MaxUint64}
 	unknownCostEstimate = unknownSizeEstimate.MultiplyByCostFactor(1)
 

common/cost/BUILD.bazel

@@ -0,0 +1,25 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+package(
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],  # Apache 2.0
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cost.go",
+    ],
+    importpath = "cel.dev/cel-go/common/cost",
+)
+
+go_test(
+    name = "go_default_test",
+    size = "small",
+    srcs = [
+        "cost_test.go",
+    ],
+    embed = [
+        ":go_default_library",
+    ],
+)