Fix parsed-only evaluation for type equality

PiperOrigin-RevId: 872633409

Author: l46kok

runtime/src/main/java/dev/cel/runtime/planner/NamespacedAttribute.java

@@ -20,11 +20,13 @@
 import dev.cel.common.types.CelType;
 import dev.cel.common.types.CelTypeProvider;
 import dev.cel.common.types.EnumType;
+import dev.cel.common.types.SimpleType;
 import dev.cel.common.types.TypeType;
 import dev.cel.common.values.CelValue;
 import dev.cel.common.values.CelValueConverter;
 import dev.cel.runtime.GlobalResolver;
 import java.util.NoSuchElementException;
+import org.jspecify.annotations.Nullable;
 
 @Immutable
 final class NamespacedAttribute implements Attribute {
@@ -34,6 +36,14 @@ final class NamespacedAttribute implements Attribute {
   private final CelValueConverter celValueConverter;
   private final CelTypeProvider typeProvider;
 
+  ImmutableList<Qualifier> qualifiers() {
+    return qualifiers;
+  }
+
+  ImmutableSet<String> candidateVariableNames() {
+    return namespacedNames;
+  }
+
   @Override
   public Object resolve(GlobalResolver ctx, ExecutionFrame frame) {
     GlobalResolver inputVars = ctx;
@@ -59,41 +69,62 @@ public Object resolve(GlobalResolver ctx, ExecutionFrame frame) {
         }
       }
 
-      CelType type = typeProvider.findType(name).orElse(null);
-      if (type != null) {
-        if (qualifiers.isEmpty()) {
-          // Resolution of a fully qualified type name: foo.bar.baz
-          return TypeType.create(type);
-        } else {
-          // This is potentially a fully qualified reference to an enum value
-          if (type instanceof EnumType && qualifiers.size() == 1) {
-            EnumType enumType = (EnumType) type;
-            String strQualifier = (String) qualifiers.get(0).value();
-            return enumType
-                .findNumberByName(strQualifier)
-                .orElseThrow(
-                    () ->
-                        new NoSuchElementException(
-                            String.format(
-                                "Field %s was not found on enum %s",
-                                enumType.name(), strQualifier)));
-          }
-        }
-
-        throw new IllegalStateException(
-            "Unexpected type resolution when there were remaining qualifiers: " + type.name());
+      // Attempt to resolve the qualify type name if the name is not a variable identifier
+      value = findIdent(name);
+      if (value != null) {
+        return value;
       }
     }
 
     return MissingAttribute.newMissingAttribute(namespacedNames);
   }
 
-  ImmutableList<Qualifier> qualifiers() {
-    return qualifiers;
+  private @Nullable Object findIdent(String name) {
+    CelType type = typeProvider.findType(name).orElse(null);
+    // If the name resolves directly, this is a fully qualified type name
+    // (ex: 'int' or 'google.protobuf.Timestamp')
+    if (type != null) {
+      if (qualifiers.isEmpty()) {
+        // Resolution of a fully qualified type name: foo.bar.baz
+        if (type instanceof TypeType) {
+          // Coalesce all type(foo) "type" into a sentinel runtime type to allow for
+          // erasure based type comparisons
+          return TypeType.create(SimpleType.DYN);
+        }
+
+        return TypeType.create(type);
+      }
+
+      throw new IllegalStateException(
+          "Unexpected type resolution when there were remaining qualifiers: " + type.name());
+    }
+
+    // The name itself could be a fully qualified reference to an enum value
+    // (e.g: my.enum_type.BAR)
+    int lastDotIndex = name.lastIndexOf('.');
+    if (lastDotIndex > 0) {
+      String enumTypeName = name.substring(0, lastDotIndex);
+      String enumValueQualifier = name.substring(lastDotIndex + 1);
+
+      return typeProvider
+          .findType(enumTypeName)
+          .filter(EnumType.class::isInstance)
+          .map(EnumType.class::cast)
+          .map(enumType -> getEnumValue(enumType, enumValueQualifier))
+          .orElse(null);
+    }
+
+    return null;
   }
 
-  ImmutableSet<String> candidateVariableNames() {
-    return namespacedNames;
+  private static Long getEnumValue(EnumType enumType, String field) {
+    return enumType
+        .findNumberByName(field)
+        .map(Integer::longValue)
+        .orElseThrow(
+            () ->
+                new NoSuchElementException(
+                    String.format("Field %s was not found on enum %s", enumType.name(), field)));
   }
 
   private GlobalResolver unwrapToNonLocal(GlobalResolver resolver) {

runtime/src/test/java/dev/cel/runtime/planner/ProgramPlannerTest.java

@@ -277,7 +277,33 @@ public void plan_ident_enum() throws Exception {
 
     Object result = program.eval();
 
-    assertThat(result).isEqualTo(1);
+    assertThat(result).isEqualTo(1L);
+  }
+
+  @Test
+  public void plan_ident_enumContainer() throws Exception {
+    CelContainer container = CelContainer.ofName(GlobalEnum.getDescriptor().getFullName());
+    CelCompiler compiler =
+        CelCompilerFactory.standardCelCompilerBuilder()
+            .addMessageTypes(TestAllTypes.getDescriptor())
+            .setContainer(container)
+            .build();
+    CelAbstractSyntaxTree ast = compile(compiler, GlobalEnum.GAR.name());
+    ProgramPlanner planner =
+        ProgramPlanner.newPlanner(
+            TYPE_PROVIDER,
+            VALUE_PROVIDER,
+            newDispatcher(),
+            CEL_VALUE_CONVERTER,
+            container,
+            CEL_OPTIONS,
+            ImmutableSet.of());
+
+    Program program = planner.plan(ast);
+
+    Object result = program.eval();
+
+    assertThat(result).isEqualTo(1L);
   }
 
   @Test
@@ -300,6 +326,18 @@ public void planIdent_typeLiteral(@TestParameter TypeLiteralTestCase testCase) t
     assertThat(result).isEqualTo(testCase.type);
   }
 
+  @Test
+  public void planIdent_typeLiteral_equality(@TestParameter TypeLiteralTestCase testCase)
+      throws Exception {
+    // ex: type(bool) == type, type(TestAllTypes) == type
+    CelAbstractSyntaxTree ast = compile(String.format("type(%s) == type", testCase.expression));
+    Program program = PLANNER.plan(ast);
+
+    boolean result = (boolean) program.eval();
+
+    assertThat(result).isTrue();
+  }
+
   @Test
   public void plan_ident_missingAttribute_throws() throws Exception {
     CelAbstractSyntaxTree ast = compile("int_var");