No public description

PiperOrigin-RevId: 997600157

Author: l46kok

common/src/main/java/dev/cel/common/values/BUILD.bazel

@@ -329,6 +329,7 @@ java_library(
     deps = [
         ":base_proto_cel_value_converter",
         ":optimized_selectable",
+        ":preadapted_list",
         ":select_field",
         ":values",
         "//:auto_value",
@@ -360,6 +361,7 @@ cel_android_library(
     deps = [
         ":base_proto_cel_value_converter_android",
         ":optimized_selectable_android",
+        ":preadapted_list_android",
         ":select_field_android",
         ":values_android",
         "//:auto_value",

common/src/main/java/dev/cel/common/values/ProtoLiteCelValueConverter.java

@@ -25,12 +25,14 @@
 import com.google.protobuf.ByteString;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.ExtensionRegistryLite;
+import com.google.protobuf.Internal.EnumLite;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.MessageLite;
 import com.google.protobuf.WireFormat;
 import dev.cel.common.annotations.Internal;
 import dev.cel.common.internal.CelLiteDescriptorPool;
 import dev.cel.common.internal.WellKnownProto;
+import dev.cel.protobuf.CelLiteDescriptor;
 import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor;
 import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.EncodingType;
 import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor.JavaType;
@@ -118,34 +120,39 @@ private Object readLengthDelimitedField(
         return CelByteString.of(inputStream.readByteArray());
       case MESSAGE:
         return mergeOrReadMessageField(
-            inputStream.readBytes(), fieldDescriptor.getFieldProtoTypeName(), existingValue);
+            inputStream.readBytes(),
+            fieldDescriptor.getFieldProtoTypeName(),
+            existingValue,
+            /* isView= */ true);
       case STRING:
         return inputStream.readStringRequireUtf8();
       default:
         throw new IllegalStateException("Unexpected field type: " + fieldType);
     }
   }
 
+  // Reads bytes of their own, not a view of another message's.
   private Object readMessageField(ByteString bytes, String fieldProtoTypeName) {
-    return mergeOrReadMessageField(bytes, fieldProtoTypeName, /* existingValue= */ null);
+    return mergeOrReadMessageField(
+        bytes, fieldProtoTypeName, /* existingValue= */ null, /* isView= */ false);
   }
 
   private Object mergeOrReadMessageField(
-      ByteString bytes, String fieldProtoTypeName, @Nullable Object existingValue) {
+      ByteString bytes, String fieldProtoTypeName, @Nullable Object existingValue, boolean isView) {
     MessageLiteDescriptor descriptor =
         descriptorPool.findDescriptor(fieldProtoTypeName).orElse(null);
     if (descriptor == null) {
       if (existingValue instanceof RawProtoMessageLiteValue) {
         bytes = ((RawProtoMessageLiteValue) existingValue).toByteString().concat(bytes);
       }
-      return RawProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this, /* isView= */ true);
+      return RawProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this, isView);
     }
     WellKnownProto wellKnownProto = WellKnownProto.getByTypeName(fieldProtoTypeName).orElse(null);
     if (isStructLike(wellKnownProto)) {
       if (existingValue instanceof ProtoMessageLiteValue) {
         bytes = ((ProtoMessageLiteValue) existingValue).toByteString().concat(bytes);
       }
-      return ProtoMessageLiteValue.create(bytes, fieldProtoTypeName, this);
+      return ProtoMessageLiteValue.create(bytes, descriptor, this);
     }
     if (existingValue instanceof MessageLite) {
       return mergeMessageLite(((MessageLite) existingValue).toBuilder(), bytes, fieldProtoTypeName);
@@ -169,18 +176,7 @@ private Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName,
         .flatMap(desc -> desc.findByFieldNumber(fieldNumber));
   }
 
-  Optional<FieldLiteDescriptor> findFieldDescriptor(String protoTypeName, String fieldName) {
-    return descriptorPool
-        .findDescriptor(protoTypeName)
-        .flatMap(desc -> desc.findByFieldName(fieldName));
-  }
-
-  MessageLite parseMessageLite(ByteString bytes, String protoTypeName) {
-    MessageLiteDescriptor descriptor = descriptorPool.getDescriptorOrThrow(protoTypeName);
-    return parseMessageLite(bytes, descriptor);
-  }
-
-  private static MessageLite parseMessageLite(ByteString bytes, MessageLiteDescriptor descriptor) {
+  static MessageLite parseMessageLite(ByteString bytes, MessageLiteDescriptor descriptor) {
     if (bytes.isEmpty()) {
       return descriptor.newMessageBuilder().getDefaultInstanceForType();
     }
@@ -216,7 +212,7 @@ private Object toRuntimeValue(MessageLite msg, MessageLiteDescriptor descriptor)
     WellKnownProto wellKnownProto =
         WellKnownProto.getByTypeName(descriptor.getProtoTypeName()).orElse(null);
     if (isStructLike(wellKnownProto)) {
-      return ProtoMessageLiteValue.create(msg, descriptor.getProtoTypeName(), this);
+      return ProtoMessageLiteValue.create(msg, descriptor, this);
     }
 
     return fromWellKnownProto(msg, checkNotNull(wellKnownProto));
@@ -464,6 +460,120 @@ boolean hasFieldByNumber(ByteString bytes, String protoTypeName, SelectField fie
     return false;
   }
 
+  /**
+   * Reads {@code fieldDescriptor} of {@code message} with its generated getter rather than from
+   * wire bytes: its CEL value, null if it's absent, or {@link CelLiteDescriptor#NO_GETTER} if it
+   * can't be read that way.
+   */
+  @SuppressWarnings("ReferenceEquality") // NO_GETTER is a sentinel instance.
+  @Nullable Object readFieldByGetter(
+      ProtoMessageLiteValue message, FieldLiteDescriptor fieldDescriptor) {
+    MessageLite msg = message.rawValue();
+    if (msg == null) {
+      return CelLiteDescriptor.NO_GETTER;
+    }
+    Object value = message.descriptor().getFieldValue(msg, fieldDescriptor.getFieldNumber());
+    if (value == null || value == CelLiteDescriptor.NO_GETTER) {
+      return value;
+    }
+    switch (fieldDescriptor.getEncodingType()) {
+      case LIST:
+        List<?> list = (List<?>) value;
+        if (list.isEmpty()) {
+          return null;
+        }
+        switch (fieldDescriptor.getProtoFieldType()) {
+          case INT64:
+          case SINT64:
+          case SFIXED64:
+          case DOUBLE:
+          case BOOL:
+          case STRING:
+            // These elements are their own CEL values, so the immutable list needn't be copied.
+            return CelPreAdaptedList.wrap(list);
+          default:
+            break;
+        }
+        ImmutableList.Builder<Object> listBuilder =
+            ImmutableList.builderWithExpectedSize(list.size());
+        for (int i = 0; i < list.size(); i++) {
+          listBuilder.add(fromGetterValue(list.get(i), fieldDescriptor));
+        }
+        return listBuilder.build();
+      case MAP:
+        Map<?, ?> map = (Map<?, ?>) value;
+        if (map.isEmpty()) {
+          return null;
+        }
+        MessageLiteDescriptor entryDescriptor =
+            descriptorPool.getDescriptorOrThrow(fieldDescriptor.getFieldProtoTypeName());
+        FieldLiteDescriptor keyDescriptor =
+            entryDescriptor.getByFieldNumberOrThrow(MAP_KEY_FIELD_NUMBER);
+        FieldLiteDescriptor valueDescriptor =
+            entryDescriptor.getByFieldNumberOrThrow(MAP_VALUE_FIELD_NUMBER);
+        ImmutableMap.Builder<Object, Object> mapBuilder =
+            ImmutableMap.builderWithExpectedSize(map.size());
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+          mapBuilder.put(
+              fromGetterValue(entry.getKey(), keyDescriptor),
+              fromGetterValue(entry.getValue(), valueDescriptor));
+        }
+        return mapBuilder.buildOrThrow();
+      case SINGULAR:
+        return fromGetterValue(value, fieldDescriptor);
+    }
+    throw new IllegalStateException(
+        "Unexpected encoding type: " + fieldDescriptor.getEncodingType());
+  }
+
+  /** Like {@link #hasFieldByNumber}, through the field's generated getter if it has one. */
+  @SuppressWarnings("ReferenceEquality") // NO_GETTER is a sentinel instance.
+  Object hasByGetter(ProtoMessageLiteValue message, SelectField field) {
+    MessageLite msg = message.rawValue();
+    if (msg == null) {
+      return CelLiteDescriptor.NO_GETTER;
+    }
+    Object value = message.descriptor().getFieldValue(msg, field.fieldNumber());
+    if (value == CelLiteDescriptor.NO_GETTER) {
+      return value;
+    }
+    if (value instanceof List) {
+      return !((List<?>) value).isEmpty();
+    }
+    if (value instanceof Map) {
+      return !((Map<?, ?>) value).isEmpty();
+    }
+    return value != null;
+  }
+
+  /** Converts a field's (or element's) Java value as returned by its getter to its CEL value. */
+  private Object fromGetterValue(Object value, FieldLiteDescriptor fieldDescriptor) {
+    switch (fieldDescriptor.getProtoFieldType()) {
+      case UINT32:
+      case FIXED32:
+        return UnsignedLong.fromLongBits(Integer.toUnsignedLong((Integer) value));
+      case UINT64:
+      case FIXED64:
+        return UnsignedLong.fromLongBits((Long) value);
+      case ENUM:
+        // Open enums are read as their numbers; closed ones as enum constants.
+        return value instanceof Integer
+            ? ((Integer) value).longValue()
+            : (long) ((EnumLite) value).getNumber();
+      case MESSAGE:
+        MessageLite message = (MessageLite) value;
+        MessageLiteDescriptor descriptor = descriptorPool.findDescriptor(message).orElse(null);
+        // A submessage whose class has no descriptor is read from its own bytes, not its root's:
+        // by its type's descriptor if the pool has one for another class (such as an older
+        // version of it), or else descriptorless.
+        return descriptor != null
+            ? toRuntimeValue(message, descriptor)
+            : readMessageField(message.toByteString(), fieldDescriptor.getFieldProtoTypeName());
+      default:
+        return super.toRuntimeValue(value);
+    }
+  }
+
   /** Describes {@code field} by the type information it carries, built once and kept on it. */
   private static FieldLiteDescriptor newFieldDescriptor(SelectField field) {
     Object cached = field.liteFieldDescriptor();

common/src/main/java/dev/cel/common/values/ProtoMessageLiteValue.java

@@ -24,7 +24,9 @@
 import dev.cel.common.exceptions.CelAttributeNotFoundException;
 import dev.cel.common.types.CelType;
 import dev.cel.common.types.StructTypeReference;
+import dev.cel.protobuf.CelLiteDescriptor;
 import dev.cel.protobuf.CelLiteDescriptor.FieldLiteDescriptor;
+import dev.cel.protobuf.CelLiteDescriptor.MessageLiteDescriptor;
 import java.util.Objects;
 import java.util.Optional;
 import org.jspecify.annotations.Nullable;
@@ -66,20 +68,24 @@ abstract class ProtoMessageLiteValue extends StructValue<String, MessageLite>
   // re-serializing intermediate hops; lazily parsed into a MessageLite only if value() is called.
   abstract @Nullable ByteString wireBytes();
 
-  @Override
-  public abstract CelType celType();
+  abstract MessageLiteDescriptor descriptor();
 
   abstract ProtoLiteCelValueConverter protoLiteCelValueConverter();
 
+  @Override
+  public CelType celType() {
+    // Built on demand, since one of these values is created on every hop but rarely asked its type.
+    return StructTypeReference.create(descriptor().getProtoTypeName());
+  }
+
   @Memoized
   @Override
   public MessageLite value() {
     MessageLite msg = rawValue();
     if (msg != null) {
       return msg;
     }
-    return protoLiteCelValueConverter()
-        .parseMessageLite(checkNotNull(wireBytes()), celType().name());
+    return ProtoLiteCelValueConverter.parseMessageLite(checkNotNull(wireBytes()), descriptor());
   }
 
   @Memoized
@@ -110,80 +116,102 @@ public final boolean equals(Object other) {
       return false;
     }
     ProtoMessageLiteValue that = (ProtoMessageLiteValue) other;
-    return this.celType().equals(that.celType()) && this.value().equals(that.value());
+    return this.descriptor().getProtoTypeName().equals(that.descriptor().getProtoTypeName())
+        && this.value().equals(that.value());
   }
 
   @Override
   public final int hashCode() {
-    return Objects.hash(value(), celType());
+    return Objects.hash(value(), descriptor().getProtoTypeName());
   }
 
   @Override
   public Object select(String field) {
-    FieldLiteDescriptor fd = findFieldDescriptor(field).orElse(null);
+    FieldLiteDescriptor fd = descriptor().findByFieldName(field).orElse(null);
     if (fd == null) {
       throw CelAttributeNotFoundException.of(
-          String.format("field '%s' is not declared in message '%s'", field, celType().name()));
+          String.format(
+              "field '%s' is not declared in message '%s'",
+              field, descriptor().getProtoTypeName()));
     }
     Object fieldValue = readField(fd);
     return fieldValue != null ? fieldValue : protoLiteCelValueConverter().getDefaultCelValue(fd);
   }
 
   @Override
   public Optional<Object> find(String field) {
-    FieldLiteDescriptor fd = findFieldDescriptor(field).orElse(null);
     // Per SelectableValue#find, a field that doesn't exist is reported as absent.
-    return Optional.ofNullable(fd).map(value -> readField(value));
+    return descriptor().findByFieldName(field).map(this::readField);
   }
 
+  // An in-memory message is read through its descriptor's generated getters, falling back to its
+  // wire bytes (which serializes it) only for fields without one, such as those unknown to its
+  // descriptor. Other messages are read from their wire bytes.
+
   @Override
   public Object selectByFieldNumber(SelectField field) {
-    return protoLiteCelValueConverter()
-        .selectByFieldNumber(toByteString(), celType().name(), field);
+    FieldLiteDescriptor fd = descriptor().findByFieldNumber(field.fieldNumber()).orElse(null);
+    if (fd == null) {
+      return protoLiteCelValueConverter()
+          .selectByFieldNumber(toByteString(), descriptor().getProtoTypeName(), field);
+    }
+    Object fieldValue = readField(fd);
+    if (fieldValue != null) {
+      return fieldValue;
+    }
+    return field.defaultValue() != null
+        ? field.defaultValue()
+        : protoLiteCelValueConverter().getDefaultCelValue(fd);
   }
 
   @Override
+  @SuppressWarnings("ReferenceEquality") // NO_GETTER is a sentinel instance.
   public boolean hasFieldByNumber(SelectField field) {
-    return protoLiteCelValueConverter().hasFieldByNumber(toByteString(), celType().name(), field);
+    Object present = protoLiteCelValueConverter().hasByGetter(this, field);
+    return present != CelLiteDescriptor.NO_GETTER
+        ? (Boolean) present
+        : protoLiteCelValueConverter()
+            .hasFieldByNumber(toByteString(), descriptor().getProtoTypeName(), field);
   }
 
   @Override
   public Optional<Object> findByFieldNumber(SelectField field) {
-    return protoLiteCelValueConverter().findByFieldNumber(toByteString(), celType().name(), field);
+    FieldLiteDescriptor fd = descriptor().findByFieldNumber(field.fieldNumber()).orElse(null);
+    return fd != null
+        ? Optional.ofNullable(readField(fd))
+        : protoLiteCelValueConverter()
+            .findByFieldNumber(toByteString(), descriptor().getProtoTypeName(), field);
   }
 
+  @SuppressWarnings("ReferenceEquality") // NO_GETTER is a sentinel instance.
   private @Nullable Object readField(FieldLiteDescriptor fd) {
-    return protoLiteCelValueConverter().readField(toByteString(), celType().name(), fd);
-  }
-
-  private Optional<FieldLiteDescriptor> findFieldDescriptor(String fieldName) {
-    return protoLiteCelValueConverter().findFieldDescriptor(celType().name(), fieldName);
+    Object value = protoLiteCelValueConverter().readFieldByGetter(this, fd);
+    return value != CelLiteDescriptor.NO_GETTER
+        ? value
+        : protoLiteCelValueConverter()
+            .readField(toByteString(), descriptor().getProtoTypeName(), fd);
   }
 
   static ProtoMessageLiteValue create(
-      MessageLite value, String typeName, ProtoLiteCelValueConverter protoLiteCelValueConverter) {
+      MessageLite value,
+      MessageLiteDescriptor descriptor,
+      ProtoLiteCelValueConverter protoLiteCelValueConverter) {
     checkNotNull(value);
-    checkNotNull(typeName);
+    checkNotNull(descriptor);
     checkNotNull(protoLiteCelValueConverter);
     return new AutoValue_ProtoMessageLiteValue(
-        value,
-        /* wireBytes= */ null,
-        StructTypeReference.create(typeName),
-        protoLiteCelValueConverter);
+        value, /* wireBytes= */ null, descriptor, protoLiteCelValueConverter);
   }
 
   static ProtoMessageLiteValue create(
       ByteString wireBytes,
-      String typeName,
+      MessageLiteDescriptor descriptor,
       ProtoLiteCelValueConverter protoLiteCelValueConverter) {
     checkNotNull(wireBytes);
-    checkNotNull(typeName);
+    checkNotNull(descriptor);
     checkNotNull(protoLiteCelValueConverter);
     return new AutoValue_ProtoMessageLiteValue(
-        /* rawValue= */ null,
-        wireBytes,
-        StructTypeReference.create(typeName),
-        protoLiteCelValueConverter);
+        /* rawValue= */ null, wireBytes, descriptor, protoLiteCelValueConverter);
   }
 
   ProtoMessageLiteValue() {}