From 556103f19978c116453642d0f8cdbe817cf242a3 Mon Sep 17 00:00:00 2001 From: Sean Huh Date: Fri, 6 Nov 2026 14:06:34 -0800 Subject: [PATCH] Don't let `dyn` list elements or optional values be unknown PiperOrigin-RevId: 1015841970 --- .../CelZ3TypeConstraintGenerator.java | 21 +++++++++---------- .../cel/verifier/CelVerifierZ3ImplTest.java | 7 ++++++- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeConstraintGenerator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeConstraintGenerator.java index 8826f8a43..485c7b65a 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeConstraintGenerator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeConstraintGenerator.java @@ -58,15 +58,15 @@ BoolExpr createTypeConstraintForType(Expr val, CelType type) { if (type instanceof OptionalType) { BoolExpr isOpt = typeSystem.isOptional(val); CelType paramType = type.parameters().get(0); - if (!CelZ3OperatorTranslator.isStaticallyKnown(paramType)) { - return isOpt; - } Expr optRef = typeSystem.getOptionalRef(val); BoolExpr hasValue = typeSystem.optHasValue(optRef); Expr optVal = typeSystem.getOptionalValue(optRef); - BoolExpr optValNotError = ctx.mkNot(typeSystem.isError(optVal)); - BoolExpr valConstraint = createTypeConstraintForType(optVal, paramType); - return ctx.mkAnd(isOpt, ctx.mkImplies(hasValue, ctx.mkAnd(optValNotError, valConstraint))); + // An input's value is never an error or unknown, even when its type is dyn. + BoolExpr valConstraint = + ctx.mkAnd( + ctx.mkNot(typeSystem.isErrorOrUnknown(optVal)), + createTypeConstraintForType(optVal, paramType)); + return ctx.mkAnd(isOpt, ctx.mkImplies(hasValue, valConstraint)); } if (type.equals(SimpleType.BOOL)) { return typeSystem.isBool(val); @@ -107,7 +107,7 @@ BoolExpr createTypeConstraintForType(Expr val, CelType type) { if (type instanceof ListType) { // Constrain list elements using bounded unrolling up to comprehensionUnrollLimit rather // than Z3 forall quantifiers to prevent MBQI quantifier instantiation loops. - // Assert: isList(val) ∧ for all unrolled 0 <= i < length: ¬isError(seq[i]) ∧ + // Assert: isList(val) ∧ for all unrolled 0 <= i < length: ¬isErrorOrUnknown(seq[i]) ∧ // typeConstraint(seq[i]). BoolExpr isList = typeSystem.isList(val); CelType elemType = ((ListType) type).elemType(); @@ -129,9 +129,8 @@ BoolExpr createTypeConstraintForType(Expr val, CelType type) { IntExpr idx = ctx.mkInt(i); Expr elem = ctx.mkNth(seq, idx); BoolExpr validIndex = ctx.mkLt(idx, length); - // Assert ¬isError(elem) as a domain invariant so Z3 never synthesizes an Error element in - // list(dyn). For concrete types, this is already implied by createTypeConstraintForType. - boundsAndTypes.add(ctx.mkImplies(validIndex, ctx.mkNot(typeSystem.isError(elem)))); + // Elements are never errors or unknowns, even in list(dyn). + boundsAndTypes.add(ctx.mkImplies(validIndex, ctx.mkNot(typeSystem.isErrorOrUnknown(elem)))); BoolExpr elemConstraint = createTypeConstraintForType(elem, elemType); boundsAndTypes.add(ctx.mkImplies(validIndex, elemConstraint)); } @@ -143,7 +142,7 @@ BoolExpr createTypeConstraintForType(Expr val, CelType type) { // Doing so forces MBQI into an infinite loop. Instead, constrain keys and values using // bounded unrolling over the key sequence up to comprehensionUnrollLimit. // Assert: isMap(val) ∧ for all unrolled 0 <= i < length: isPrimitiveKey(key) ∧ ¬isError(key) - // ∧ (presence(key) ⇒ ¬isError(val) ∧ typeConstraint(val)) + // ∧ (presence(key) ⇒ ¬isErrorOrUnknown(val) ∧ typeConstraint(val)) BoolExpr isMap = typeSystem.isMap(val); MapType mapType = (MapType) type; CelType keyType = mapType.keyType(); diff --git a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java index 5c99d431c..70a3156f5 100644 --- a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java +++ b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java @@ -905,6 +905,11 @@ public void isSatisfiable_timeout_throwsException() throws Exception { private enum IsAlwaysTrueTestCase { LOGICAL_OR_CONSTANTS("true || false"), + // Elements of `dyn` inputs are never unknown. + DYN_LIST_ELEMENT_NOT_UNKNOWN( + "size(dyn_list) == 1 ? (dyn_list.exists(x, x == 1) || !dyn_list.exists(x, x == 1)) : true"), + DYN_OPTIONAL_VALUE_NOT_UNKNOWN( + "opt_dyn_var.hasValue() ? (opt_dyn_var.value() == 1 || opt_dyn_var.value() != 1) : true"), BOOL_ORDERING( "false < true && !(true < false) && false <= true && !(true <= false) && true > false" + " && !(false > true) && true >= false && !(false >= true)"), @@ -1872,7 +1877,7 @@ private enum IsAlwaysTrueViolationTestCase { "opt_dyn_var.hasValue() ? type(opt_dyn_var.value()) == int : true", "Condition is not always true\\.", "Counterexample input:", - "opt_dyn_var = optional\\.of\\(Unknown\\)"), + "opt_dyn_var = optional\\.of\\((?!Unknown|Error)"), OPTIONAL_ENTRY_DYN_VAR_TYPE_MISMATCH( "[?dyn_var] == [?dyn_var] ? true : true", "Condition is not always true\\.",