Bump cel-go to v0.12.0

vendor/github.com/google/cel-go/checker/BUILD.bazel

@@ -54,7 +54,7 @@ go_test(
         "//test:go_default_library",
         "//test/proto2pb:go_default_library",
         "//test/proto3pb:go_default_library",
-        "@com_github_antlr//runtime/Go/antlr:go_default_library",
+        "@com_github_antlr_antlr4_runtime_go_antlr//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

vendor/github.com/google/cel-go/checker/checker.go

@@ -187,7 +187,7 @@ func (c *checker) checkSelect(e *exprpb.Expr) {
 
 	// Interpret as field selection, first traversing down the operand.
 	c.check(sel.Operand)
-	targetType := c.getType(sel.Operand)
+	targetType := substitute(c.mappings, c.getType(sel.Operand), false)
 	// Assume error type by default as most types do not support field selection.
 	resultType := decls.Error
 	switch kindOf(targetType) {
@@ -224,7 +224,7 @@ func (c *checker) checkSelect(e *exprpb.Expr) {
 	if sel.TestOnly {
 		resultType = decls.Bool
 	}
-	c.setType(e, resultType)
+	c.setType(e, substitute(c.mappings, resultType, false))
 }
 
 func (c *checker) checkCall(e *exprpb.Expr) {
@@ -469,18 +469,18 @@ func (c *checker) checkCreateMessage(e *exprpb.Expr) {
 
 func (c *checker) checkComprehension(e *exprpb.Expr) {
 	comp := e.GetComprehensionExpr()
-	c.check(comp.IterRange)
-	c.check(comp.AccuInit)
-	accuType := c.getType(comp.AccuInit)
-	rangeType := c.getType(comp.IterRange)
+	c.check(comp.GetIterRange())
+	c.check(comp.GetAccuInit())
+	accuType := c.getType(comp.GetAccuInit())
+	rangeType := substitute(c.mappings, c.getType(comp.GetIterRange()), false)
 	var varType *exprpb.Type
 
 	switch kindOf(rangeType) {
 	case kindList:
-		varType = rangeType.GetListType().ElemType
+		varType = rangeType.GetListType().GetElemType()
 	case kindMap:
 		// Ranges over the keys.
-		varType = rangeType.GetMapType().KeyType
+		varType = rangeType.GetMapType().GetKeyType()
 	case kindDyn, kindError, kindTypeParam:
 		// Set the range type to DYN to prevent assignment to a potentially incorrect type
 		// at a later point in type-checking. The isAssignable call will update the type
@@ -489,28 +489,28 @@ func (c *checker) checkComprehension(e *exprpb.Expr) {
 		// Set the range iteration variable to type DYN as well.
 		varType = decls.Dyn
 	default:
-		c.errors.notAComprehensionRange(c.location(comp.IterRange), rangeType)
+		c.errors.notAComprehensionRange(c.location(comp.GetIterRange()), rangeType)
 		varType = decls.Error
 	}
 
 	// Create a scope for the comprehension since it has a local accumulation variable.
 	// This scope will contain the accumulation variable used to compute the result.
 	c.env = c.env.enterScope()
-	c.env.Add(decls.NewVar(comp.AccuVar, accuType))
+	c.env.Add(decls.NewVar(comp.GetAccuVar(), accuType))
 	// Create a block scope for the loop.
 	c.env = c.env.enterScope()
-	c.env.Add(decls.NewVar(comp.IterVar, varType))
+	c.env.Add(decls.NewVar(comp.GetIterVar(), varType))
 	// Check the variable references in the condition and step.
-	c.check(comp.LoopCondition)
-	c.assertType(comp.LoopCondition, decls.Bool)
-	c.check(comp.LoopStep)
-	c.assertType(comp.LoopStep, accuType)
+	c.check(comp.GetLoopCondition())
+	c.assertType(comp.GetLoopCondition(), decls.Bool)
+	c.check(comp.GetLoopStep())
+	c.assertType(comp.GetLoopStep(), accuType)
 	// Exit the loop's block scope before checking the result.
 	c.env = c.env.exitScope()
-	c.check(comp.Result)
+	c.check(comp.GetResult())
 	// Exit the comprehension scope.
 	c.env = c.env.exitScope()
-	c.setType(e, c.getType(comp.Result))
+	c.setType(e, substitute(c.mappings, c.getType(comp.GetResult()), false))
 }
 
 // Checks compatibility of joined types, and returns the most general common type.

vendor/github.com/google/cel-go/checker/env.go

@@ -181,8 +181,7 @@ func (e *Env) addOverload(f *exprpb.Decl, overload *exprpb.Decl_FunctionDecl_Ove
 		overload.GetParams()...)
 	overloadErased := substitute(emptyMappings, overloadFunction, true)
 	for _, existing := range function.GetOverloads() {
-		existingFunction := decls.NewFunctionType(existing.GetResultType(),
-			existing.GetParams()...)
+		existingFunction := decls.NewFunctionType(existing.GetResultType(), existing.GetParams()...)
 		existingErased := substitute(emptyMappings, existingFunction, true)
 		overlap := isAssignable(emptyMappings, overloadErased, existingErased) != nil ||
 			isAssignable(emptyMappings, existingErased, overloadErased) != nil
@@ -213,18 +212,33 @@ func (e *Env) addOverload(f *exprpb.Decl, overload *exprpb.Decl_FunctionDecl_Ove
 // Adds a function decl if one doesn't already exist, then adds all overloads from the Decl.
 // If overload overlaps with an existing overload, adds to the errors  in the Env instead.
 func (e *Env) setFunction(decl *exprpb.Decl) []errorMsg {
+	errorMsgs := make([]errorMsg, 0)
+	overloads := decl.GetFunction().GetOverloads()
 	current := e.declarations.FindFunction(decl.Name)
 	if current == nil {
 		//Add the function declaration without overloads and check the overloads below.
 		current = decls.NewFunction(decl.Name)
 	} else {
+		existingOverloads := map[string]*exprpb.Decl_FunctionDecl_Overload{}
+		for _, overload := range current.GetFunction().GetOverloads() {
+			existingOverloads[overload.GetOverloadId()] = overload
+		}
+		newOverloads := []*exprpb.Decl_FunctionDecl_Overload{}
+		for _, overload := range overloads {
+			existing, found := existingOverloads[overload.GetOverloadId()]
+			if !found || !proto.Equal(existing, overload) {
+				newOverloads = append(newOverloads, overload)
+			}
+		}
+		overloads = newOverloads
+		if len(newOverloads) == 0 {
+			return errorMsgs
+		}
 		// Copy on write since we don't know where this original definition came from.
 		current = proto.Clone(current).(*exprpb.Decl)
 	}
 	e.declarations.SetFunction(current)
-
-	errorMsgs := make([]errorMsg, 0)
-	for _, overload := range decl.GetFunction().GetOverloads() {
+	for _, overload := range overloads {
 		errorMsgs = append(errorMsgs, e.addOverload(current, overload)...)
 	}
 	return errorMsgs
@@ -235,6 +249,9 @@ func (e *Env) setFunction(decl *exprpb.Decl) []errorMsg {
 func (e *Env) addIdent(decl *exprpb.Decl) errorMsg {
 	current := e.declarations.FindIdentInScope(decl.Name)
 	if current != nil {
+		if proto.Equal(current, decl) {
+			return ""
+		}
 		return overlappingIdentifierError(decl.Name)
 	}
 	e.declarations.AddIdent(decl)

vendor/github.com/google/cel-go/checker/types.go

@@ -88,6 +88,8 @@ func FormatCheckedType(t *exprpb.Type) string {
 			FormatCheckedType(decls.NewPrimitiveType(t.GetWrapper())))
 	case kindError:
 		return "!error!"
+	case kindTypeParam:
+		return t.GetTypeParam()
 	}
 	return t.String()
 }
@@ -238,14 +240,25 @@ func internalIsAssignable(m *mapping, t1 *exprpb.Type, t2 *exprpb.Type) bool {
 // - t2 has a type substitution (t2sub) assignable to t1
 // - t2 does not occur within t1.
 func isValidTypeSubstitution(m *mapping, t1, t2 *exprpb.Type) (valid, hasSub bool) {
+	// Early return if the t1 and t2 are the same instance.
+	kind1, kind2 := kindOf(t1), kindOf(t2)
+	if kind1 == kind2 && (t1 == t2 || proto.Equal(t1, t2)) {
+		return true, true
+	}
 	if t2Sub, found := m.find(t2); found {
-		kind1, kind2 := kindOf(t1), kindOf(t2)
-		if kind1 == kind2 && proto.Equal(t1, t2Sub) {
+		// Early return if t1 and t2Sub are the same instance as otherwise the mapping
+		// might mark a type as being a subtitution for itself.
+		if kind1 == kindOf(t2Sub) && (t1 == t2Sub || proto.Equal(t1, t2Sub)) {
 			return true, true
 		}
 		// If the types are compatible, pick the more general type and return true
 		if internalIsAssignable(m, t1, t2Sub) {
-			m.add(t2, mostGeneral(t1, t2Sub))
+			t2New := mostGeneral(t1, t2Sub)
+			// only update the type reference map if the target type does not occur within it.
+			if notReferencedIn(m, t2, t2New) {
+				m.add(t2, t2New)
+			}
+			// acknowledge the type agreement, and that the substitution is already tracked.
 			return true, true
 		}
 		return false, true