Enforce strictness of type function

This ensures that:
  - type(unknown) -> unknown
  - type(error) -> error

PiperOrigin-RevId: 686325313

Author: l46kok

runtime/src/main/java/dev/cel/runtime/CelUnknownSet.java

@@ -46,7 +46,7 @@ public static CelUnknownSet create(ImmutableSet<CelAttribute> attributes) {
     return create(attributes, ImmutableSet.of());
   }
 
-  static CelUnknownSet create(Long... unknownExprIds) {
+  public static CelUnknownSet create(Long... unknownExprIds) {
     return create(ImmutableSet.copyOf(unknownExprIds));
   }
 

runtime/src/main/java/dev/cel/runtime/DefaultInterpreter.java

@@ -222,10 +222,14 @@ private IntermediateResult evalInternal(ExecutionFrame frame, CelExpr expr)
       }
     }
 
-    private boolean isUnknownValue(Object value) {
+    private static boolean isUnknownValue(Object value) {
       return value instanceof CelUnknownSet || InterpreterUtil.isUnknown(value);
     }
 
+    private static boolean isUnknownOrError(Object value) {
+      return isUnknownValue(value) || value instanceof Exception;
+    }
+
     private Object evalConstant(
         ExecutionFrame unusedFrame, CelExpr unusedExpr, CelConstant constExpr) {
       switch (constExpr.getKind()) {
@@ -593,6 +597,10 @@ private IntermediateResult evalType(ExecutionFrame frame, CelCall callExpr)
         throws InterpreterException {
       CelExpr typeExprArg = callExpr.args().get(0);
       IntermediateResult argResult = evalInternal(frame, typeExprArg);
+      // Type is a strict function. Early return if the argument is an error or an unknown.
+      if (isUnknownOrError(argResult.value())) {
+        return argResult;
+      }
 
       CelType checkedType =
           ast.getType(typeExprArg.id())
@@ -682,9 +690,7 @@ private IntermediateResult evalBoolean(ExecutionFrame frame, CelExpr expr, boole
         throws InterpreterException {
       IntermediateResult value = strict ? evalInternal(frame, expr) : evalNonstrictly(frame, expr);
 
-      if (!(value.value() instanceof Boolean)
-          && !isUnknownValue(value.value())
-          && !(value.value() instanceof Exception)) {
+      if (!(value.value() instanceof Boolean) && !isUnknownOrError(value.value())) {
         throw new InterpreterException.Builder("expected boolean value, found: %s", value.value())
             .setErrorCode(CelErrorCode.INVALID_ARGUMENT)
             .setLocation(metadata, expr.id())

runtime/src/test/resources/unknownResultSet.baseline

@@ -515,3 +515,30 @@ result:   unknown {
   exprs: 3
   exprs: 6
 }
+
+
+Source: type(x.single_int32)
+declare x {
+  value google.api.expr.test.v1.proto3.TestAllTypes
+}
+declare f {
+  function f int.(int) -> bool
+}
+=====>
+bindings: {}
+result:   unknown {
+  exprs: 2
+}
+
+
+Source: type(1 / 0 > 2)
+declare x {
+  value google.api.expr.test.v1.proto3.TestAllTypes
+}
+declare f {
+  function f int.(int) -> bool
+}
+=====>
+bindings: {}
+error:    evaluation error: / by zero
+error_code:    DIVIDE_BY_ZERO

testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java

@@ -1298,6 +1298,14 @@ public void unknownResultSet() {
     // message with multiple unknowns => unknownSet
     source = "TestAllTypes{single_int32: x.single_int32, single_int64: x.single_int64}";
     runTest();
+
+    // type(unknown) -> unknown
+    source = "type(x.single_int32)";
+    runTest();
+
+    // type(error) -> error
+    source = "type(1 / 0 > 2)";
+    runTest();
   }
 
   @Test