CPP Unit Tests - Data
Collection
8 items
•
Updated
Code
stringlengths 131
28.2k
| Unit Test
stringlengths 40
32.1k
| __index_level_0__
int64 0
2.63k
|
|---|---|---|
#ifndef THIRD_PARTY_CEL_CPP_BASE_KIND_H_
#define THIRD_PARTY_CEL_CPP_BASE_KIND_H_
#include "common/kind.h"
#include "common/type_kind.h"
#include "common/value_kind.h"
#endif
#include "common/kind.h"
#include "absl/strings/string_view.h"
namespace cel {
absl::string_view KindToString(Kind kind) {
switch (kind) {
case Kind::kNullType:
return "null_type";
case Kind::kDyn:
return "dyn";
case Kind::kAny:
return "any";
case Kind::kType:
return "type";
case Kind::kTypeParam:
return "type_param";
case Kind::kFunction:
return "function";
case Kind::kBool:
return "bool";
case Kind::kInt:
return "int";
case Kind::kUint:
return "uint";
case Kind::kDouble:
return "double";
case Kind::kString:
return "string";
case Kind::kBytes:
return "bytes";
case Kind::kDuration:
return "duration";
case Kind::kTimestamp:
return "timestamp";
case Kind::kList:
return "list";
case Kind::kMap:
return "map";
case Kind::kStruct:
return "struct";
case Kind::kUnknown:
return "*unknown*";
case Kind::kOpaque:
return "*opaque*";
case Kind::kBoolWrapper:
return "google.protobuf.BoolValue";
case Kind::kIntWrapper:
return "google.protobuf.Int64Value";
case Kind::kUintWrapper:
return "google.protobuf.UInt64Value";
case Kind::kDoubleWrapper:
return "google.protobuf.DoubleValue";
case Kind::kStringWrapper:
return "google.protobuf.StringValue";
case Kind::kBytesWrapper:
return "google.protobuf.BytesValue";
default:
return "*error*";
}
}
} | #include "common/kind.h"
#include <limits>
#include <type_traits>
#include "common/type_kind.h"
#include "common/value_kind.h"
#include "internal/testing.h"
namespace cel {
namespace {
static_assert(std::is_same_v<std::underlying_type_t<TypeKind>,
std::underlying_type_t<ValueKind>>,
"TypeKind and ValueKind must have the same underlying type");
TEST(Kind, ToString) {
EXPECT_EQ(KindToString(Kind::kError), "*error*");
EXPECT_EQ(KindToString(Kind::kNullType), "null_type");
EXPECT_EQ(KindToString(Kind::kDyn), "dyn");
EXPECT_EQ(KindToString(Kind::kAny), "any");
EXPECT_EQ(KindToString(Kind::kType), "type");
EXPECT_EQ(KindToString(Kind::kBool), "bool");
EXPECT_EQ(KindToString(Kind::kInt), "int");
EXPECT_EQ(KindToString(Kind::kUint), "uint");
EXPECT_EQ(KindToString(Kind::kDouble), "double");
EXPECT_EQ(KindToString(Kind::kString), "string");
EXPECT_EQ(KindToString(Kind::kBytes), "bytes");
EXPECT_EQ(KindToString(Kind::kDuration), "duration");
EXPECT_EQ(KindToString(Kind::kTimestamp), "timestamp");
EXPECT_EQ(KindToString(Kind::kList), "list");
EXPECT_EQ(KindToString(Kind::kMap), "map");
EXPECT_EQ(KindToString(Kind::kStruct), "struct");
EXPECT_EQ(KindToString(Kind::kUnknown), "*unknown*");
EXPECT_EQ(KindToString(Kind::kOpaque), "*opaque*");
EXPECT_EQ(KindToString(Kind::kBoolWrapper), "google.protobuf.BoolValue");
EXPECT_EQ(KindToString(Kind::kIntWrapper), "google.protobuf.Int64Value");
EXPECT_EQ(KindToString(Kind::kUintWrapper), "google.protobuf.UInt64Value");
EXPECT_EQ(KindToString(Kind::kDoubleWrapper), "google.protobuf.DoubleValue");
EXPECT_EQ(KindToString(Kind::kStringWrapper), "google.protobuf.StringValue");
EXPECT_EQ(KindToString(Kind::kBytesWrapper), "google.protobuf.BytesValue");
EXPECT_EQ(KindToString(static_cast<Kind>(std::numeric_limits<int>::max())),
"*error*");
}
TEST(Kind, TypeKindRoundtrip) {
EXPECT_EQ(TypeKindToKind(KindToTypeKind(Kind::kBool)), Kind::kBool);
}
TEST(Kind, ValueKindRoundtrip) {
EXPECT_EQ(ValueKindToKind(KindToValueKind(Kind::kBool)), Kind::kBool);
}
TEST(Kind, IsTypeKind) {
EXPECT_TRUE(KindIsTypeKind(Kind::kBool));
EXPECT_TRUE(KindIsTypeKind(Kind::kAny));
EXPECT_TRUE(KindIsTypeKind(Kind::kDyn));
}
TEST(Kind, IsValueKind) {
EXPECT_TRUE(KindIsValueKind(Kind::kBool));
EXPECT_FALSE(KindIsValueKind(Kind::kAny));
EXPECT_FALSE(KindIsValueKind(Kind::kDyn));
}
TEST(Kind, Equality) {
EXPECT_EQ(Kind::kBool, TypeKind::kBool);
EXPECT_EQ(TypeKind::kBool, Kind::kBool);
EXPECT_EQ(Kind::kBool, ValueKind::kBool);
EXPECT_EQ(ValueKind::kBool, Kind::kBool);
EXPECT_NE(Kind::kBool, TypeKind::kInt);
EXPECT_NE(TypeKind::kInt, Kind::kBool);
EXPECT_NE(Kind::kBool, ValueKind::kInt);
EXPECT_NE(ValueKind::kInt, Kind::kBool);
}
TEST(TypeKind, ToString) {
EXPECT_EQ(TypeKindToString(TypeKind::kBool), KindToString(Kind::kBool));
}
TEST(ValueKind, ToString) {
EXPECT_EQ(ValueKindToString(ValueKind::kBool), KindToString(Kind::kBool));
}
}
} | 0 |
#ifndef THIRD_PARTY_CEL_CPP_COMMON_VALUE_FACTORY_H_
#define THIRD_PARTY_CEL_CPP_COMMON_VALUE_FACTORY_H_
#include <cstdint>
#include <string>
#include <utility>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "common/json.h"
#include "common/type.h"
#include "common/type_factory.h"
#include "common/unknown.h"
#include "common/value.h"
namespace cel {
namespace common_internal {
class PiecewiseValueManager;
}
class ValueFactory : public virtual TypeFactory {
public:
Value CreateValueFromJson(Json json);
ListValue CreateListValueFromJsonArray(JsonArray json);
MapValue CreateMapValueFromJsonObject(JsonObject json);
ListValue CreateZeroListValue(ListTypeView type);
MapValue CreateZeroMapValue(MapTypeView type);
OptionalValue CreateZeroOptionalValue(OptionalTypeView type);
ListValueView GetZeroDynListValue();
MapValueView GetZeroDynDynMapValue();
MapValueView GetZeroStringDynMapValue();
OptionalValueView GetZeroDynOptionalValue();
NullValue GetNullValue() { return NullValue{}; }
ErrorValue CreateErrorValue(absl::Status status) {
return ErrorValue{std::move(status)};
}
BoolValue CreateBoolValue(bool value) { return BoolValue{value}; }
IntValue CreateIntValue(int64_t value) { return IntValue{value}; }
UintValue CreateUintValue(uint64_t value) { return UintValue{value}; }
DoubleValue CreateDoubleValue(double value) { return DoubleValue{value}; }
BytesValue GetBytesValue() { return BytesValue(); }
absl::StatusOr<BytesValue> CreateBytesValue(const char* value) {
return CreateBytesValue(absl::string_view(value));
}
absl::StatusOr<BytesValue> CreateBytesValue(absl::string_view value) {
return CreateBytesValue(std::string(value));
}
absl::StatusOr<BytesValue> CreateBytesValue(std::string value);
absl::StatusOr<BytesValue> CreateBytesValue(absl::Cord value) {
return BytesValue(std::move(value));
}
template <typename Releaser>
absl::StatusOr<BytesValue> CreateBytesValue(absl::string_view value,
Releaser&& releaser) {
return BytesValue(
absl::MakeCordFromExternal(value, std::forward<Releaser>(releaser)));
}
StringValue GetStringValue() { return StringValue(); }
absl::StatusOr<StringValue> CreateStringValue(const char* value) {
return CreateStringValue(absl::string_view(value));
}
absl::StatusOr<StringValue> CreateStringValue(absl::string_view value) {
return CreateStringValue(std::string(value));
}
absl::StatusOr<StringValue> CreateStringValue(std::string value);
absl::StatusOr<StringValue> CreateStringValue(absl::Cord value);
template <typename Releaser>
absl::StatusOr<StringValue> CreateStringValue(absl::string_view value,
Releaser&& releaser) {
return StringValue(
absl::MakeCordFromExternal(value, std::forward<Releaser>(releaser)));
}
StringValue CreateUncheckedStringValue(const char* value) {
return CreateUncheckedStringValue(absl::string_view(value));
}
StringValue CreateUncheckedStringValue(absl::string_view value) {
return CreateUncheckedStringValue(std::string(value));
}
StringValue CreateUncheckedStringValue(std::string value);
StringValue CreateUncheckedStringValue(absl::Cord value) {
return StringValue(std::move(value));
}
template <typename Releaser>
StringValue CreateUncheckedStringValue(absl::string_view value,
Releaser&& releaser) {
return StringValue(
absl::MakeCordFromExternal(value, std::forward<Releaser>(releaser)));
}
absl::StatusOr<DurationValue> CreateDurationValue(absl::Duration value);
DurationValue CreateUncheckedDurationValue(absl::Duration value) {
return DurationValue{value};
}
absl::StatusOr<TimestampValue> CreateTimestampValue(absl::Time value);
TimestampValue CreateUncheckedTimestampValue(absl::Time value) {
return TimestampValue{value};
}
TypeValue CreateTypeValue(TypeView type) { return TypeValue{Type(type)}; }
UnknownValue CreateUnknownValue() {
return CreateUnknownValue(AttributeSet(), FunctionResultSet());
}
UnknownValue CreateUnknownValue(AttributeSet attribute_set) {
return CreateUnknownValue(std::move(attribute_set), FunctionResultSet());
}
UnknownValue CreateUnknownValue(FunctionResultSet function_result_set) {
return CreateUnknownValue(AttributeSet(), std::move(function_result_set));
}
UnknownValue CreateUnknownValue(AttributeSet attribute_set,
FunctionResultSet function_result_set) {
return UnknownValue{
Unknown{std::move(attribute_set), std::move(function_result_set)}};
}
protected:
friend class common_internal::PiecewiseValueManager;
virtual ListValue CreateZeroListValueImpl(ListTypeView type) = 0;
virtual MapValue CreateZeroMapValueImpl(MapTypeView type) = 0;
virtual OptionalValue CreateZeroOptionalValueImpl(OptionalTypeView type) = 0;
};
}
#endif
#include "common/value_factory.h"
#include <algorithm>
#include <cstddef>
#include <memory>
#include <new>
#include <string>
#include <utility>
#include <vector>
#include "absl/base/attributes.h"
#include "absl/base/nullability.h"
#include "absl/base/optimization.h"
#include "absl/functional/overload.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "absl/types/optional.h"
#include "absl/types/variant.h"
#include "common/casting.h"
#include "common/internal/arena_string.h"
#include "common/internal/reference_count.h"
#include "common/json.h"
#include "common/memory.h"
#include "common/native_type.h"
#include "common/type.h"
#include "common/value.h"
#include "common/value_manager.h"
#include "common/values/value_cache.h"
#include "internal/status_macros.h"
#include "internal/time.h"
#include "internal/utf8.h"
namespace cel {
namespace {
using common_internal::ProcessLocalValueCache;
void JsonToValue(const Json& json, ValueFactory& value_factory, Value& result) {
absl::visit(
absl::Overload(
[&result](JsonNull) { result = NullValue(); },
[&result](JsonBool value) { result = BoolValue(value); },
[&result](JsonNumber value) { result = DoubleValue(value); },
[&result](const JsonString& value) { result = StringValue(value); },
[&value_factory, &result](const JsonArray& value) {
result = value_factory.CreateListValueFromJsonArray(value);
},
[&value_factory, &result](const JsonObject& value) {
result = value_factory.CreateMapValueFromJsonObject(value);
}),
json);
}
void JsonDebugString(const Json& json, std::string& out);
void JsonArrayDebugString(const JsonArray& json, std::string& out) {
out.push_back('[');
auto element = json.begin();
if (element != json.end()) {
JsonDebugString(*element, out);
++element;
for (; element != json.end(); ++element) {
out.append(", ");
JsonDebugString(*element, out);
}
}
out.push_back(']');
}
void JsonObjectEntryDebugString(const JsonString& key, const Json& value,
std::string& out) {
out.append(StringValueView(key).DebugString());
out.append(": ");
JsonDebugString(value, out);
}
void JsonObjectDebugString(const JsonObject& json, std::string& out) {
std::vector<JsonString> keys;
keys.reserve(json.size());
for (const auto& entry : json) {
keys.push_back(entry.first);
}
std::stable_sort(keys.begin(), keys.end());
out.push_back('{');
auto key = keys.begin();
if (key != keys.end()) {
JsonObjectEntryDebugString(*key, json.find(*key)->second, out);
++key;
for (; key != keys.end(); ++key) {
out.append(", ");
JsonObjectEntryDebugString(*key, json.find(*key)->second, out);
}
}
out.push_back('}');
}
void JsonDebugString(const Json& json, std::string& out) {
absl::visit(absl::Overload(
[&out](JsonNull) -> void {
out.append(NullValueView().DebugString());
},
[&out](JsonBool value) -> void {
out.append(BoolValueView(value).DebugString());
},
[&out](JsonNumber value) -> void {
out.append(DoubleValueView(value).DebugString());
},
[&out](const JsonString& value) -> void {
out.append(StringValueView(value).DebugString());
},
[&out](const JsonArray& value) -> void {
JsonArrayDebugString(value, out);
},
[&out](const JsonObject& value) -> void {
JsonObjectDebugString(value, out);
}),
json);
}
class JsonListValue final : public ParsedListValueInterface {
public:
explicit JsonListValue(JsonArray array) : array_(std::move(array)) {}
std::string DebugString() const override {
std::string out;
JsonArrayDebugString(array_, out);
return out;
}
bool IsEmpty() const override { return array_.empty(); }
size_t Size() const override { return array_.size(); }
absl::StatusOr<JsonArray> ConvertToJsonArray(
AnyToJsonConverter&) const override {
return array_;
}
private:
Type GetTypeImpl(TypeManager& type_manager) const override {
return ListType(type_manager.GetDynListType());
}
absl::Status GetImpl(ValueManager& value_manager, size_t index,
Value& result) const override {
JsonToValue(array_[index], value_manager, result);
return absl::OkStatus();
}
NativeTypeId GetNativeTypeId() const noexcept override {
return NativeTypeId::For<JsonListValue>();
}
const JsonArray array_;
};
class JsonMapValueKeyIterator final : public ValueIterator {
public:
explicit JsonMapValueKeyIterator(
const JsonObject& object ABSL_ATTRIBUTE_LIFETIME_BOUND)
: begin_(object.begin()), end_(object.end()) {}
bool HasNext() override { return begin_ != end_; }
absl::Status Next(ValueManager&, Value& result) override {
if (ABSL_PREDICT_FALSE(begin_ == end_)) {
return absl::FailedPreconditionError(
"ValueIterator::Next() called when "
"ValueIterator::HasNext() returns false");
}
const auto& key = begin_->first;
++begin_;
result = StringValue(key);
return absl::OkStatus();
}
private:
typename JsonObject::const_iterator begin_;
typename JsonObject::const_iterator end_;
};
class JsonMapValue final : public ParsedMapValueInterface {
public:
explicit JsonMapValue(JsonObject object) : object_(std::move(object)) {}
std::string DebugString() const override {
std::string out;
JsonObjectDebugString(object_, out);
return out;
}
bool IsEmpty() const override { return object_.empty(); }
size_t Size() const override { return object_.size(); }
absl::Status ListKeys(ValueManager& value_manager,
ListValue& result) const override {
JsonArrayBuilder keys;
keys.reserve(object_.size());
for (const auto& entry : object_) {
keys.push_back(entry.first);
}
result = ParsedListValue(
value_manager.GetMemoryManager().MakeShared<JsonListValue>(
std::move(keys).Build()));
return absl::OkStatus();
}
absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> NewIterator(
ValueManager&) const override {
return std::make_unique<JsonMapValueKeyIterator>(object_);
}
absl::StatusOr<JsonObject> ConvertToJsonObject(
AnyToJsonConverter&) const override {
return object_;
}
private:
absl::StatusOr<bool> FindImpl(ValueManager& value_manager, ValueView key,
Value& result) const override {
return Cast<StringValueView>(key).NativeValue(absl::Overload(
[this, &value_manager, &result](absl::string_view value) -> bool {
if (auto entry = object_.find(value); entry != object_.end()) {
JsonToValue(entry->second, value_manager, result);
return true;
}
return false;
},
[this, &value_manager, &result](const absl::Cord& value) -> bool {
if (auto entry = object_.find(value); entry != object_.end()) {
JsonToValue(entry->second, value_manager, result);
return true;
}
return false;
}));
}
absl::StatusOr<bool> HasImpl(ValueManager&, ValueView key) const override {
return Cast<StringValueView>(key).NativeValue(absl::Overload(
[this](absl::string_view value) -> bool {
return object_.contains(value);
},
[this](const absl::Cord& value) -> bool {
return object_.contains(value);
}));
}
Type GetTypeImpl(TypeManager& type_manager) const override {
return MapType(type_manager.GetStringDynMapType());
}
NativeTypeId GetNativeTypeId() const noexcept override {
return NativeTypeId::For<JsonMapValue>();
}
const JsonObject object_;
};
}
Value ValueFactory::CreateValueFromJson(Json json) {
return absl::visit(
absl::Overload(
[](JsonNull) -> Value { return NullValue(); },
[](JsonBool value) -> Value { return BoolValue(value); },
[](JsonNumber value) -> Value { return DoubleValue(value); },
[](const JsonString& value) -> Value { return StringValue(value); },
[this](JsonArray value) -> Value {
return CreateListValueFromJsonArray(std::move(value));
},
[this](JsonObject value) -> Value {
return CreateMapValueFromJsonObject(std::move(value));
}),
std::move(json));
}
ListValue ValueFactory::CreateListValueFromJsonArray(JsonArray json) {
if (json.empty()) {
return ListValue(GetZeroDynListValue());
}
return ParsedListValue(
GetMemoryManager().MakeShared<JsonListValue>(std::move(json)));
}
MapValue ValueFactory::CreateMapValueFromJsonObject(JsonObject json) {
if (json.empty()) {
return MapValue(GetZeroStringDynMapValue());
}
return ParsedMapValue(
GetMemoryManager().MakeShared<JsonMapValue>(std::move(json)));
}
ListValue ValueFactory::CreateZeroListValue(ListTypeView type) {
if (auto list_value = ProcessLocalValueCache::Get()->GetEmptyListValue(type);
list_value.has_value()) {
return ListValue(*list_value);
}
return CreateZeroListValueImpl(type);
}
MapValue ValueFactory::CreateZeroMapValue(MapTypeView type) {
if (auto map_value = ProcessLocalValueCache::Get()->GetEmptyMapValue(type);
map_value.has_value()) {
return MapValue(*map_value);
}
return CreateZeroMapValueImpl(type);
}
OptionalValue ValueFactory::CreateZeroOptionalValue(OptionalTypeView type) {
if (auto optional_value =
ProcessLocalValueCache::Get()->GetEmptyOptionalValue(type);
optional_value.has_value()) {
return OptionalValue(*optional_value);
}
return CreateZeroOptionalValueImpl(type);
}
ListValueView ValueFactory::GetZeroDynListValue() {
return ProcessLocalValueCache::Get()->GetEmptyDynListValue();
}
MapValueView ValueFactory::GetZeroDynDynMapValue() {
return ProcessLocalValueCache::Get()->GetEmptyDynDynMapValue();
}
MapValueView ValueFactory::GetZeroStringDynMapValue() {
return ProcessLocalValueCache::Get()->GetEmptyStringDynMapValue();
}
OptionalValueView ValueFactory::GetZeroDynOptionalValue() {
return ProcessLocalValueCache::Get()->GetEmptyDynOptionalValue();
}
namespace {
class ReferenceCountedString final : public common_internal::ReferenceCounted {
public:
static const ReferenceCountedString* New(std::string&& string) {
return new ReferenceCountedString(std::move(string));
}
const char* data() const {
return std::launder(reinterpret_cast<const std::string*>(&string_[0]))
->data();
}
size_t size() const {
return std::launder(reinterpret_cast<const std::string*>(&string_[0]))
->size();
}
private:
explicit ReferenceCountedString(std::string&& robbed) : ReferenceCounted() {
::new (static_cast<void*>(&string_[0])) std::string(std::move(robbed));
}
void Finalize() noexcept override {
std::launder(reinterpret_cast<const std::string*>(&string_[0]))
->~basic_string();
}
alignas(std::string) char string_[sizeof(std::string)];
};
}
static void StringDestructor(void* string) {
static_cast<std::string*>(string)->~basic_string();
}
absl::StatusOr<BytesValue> ValueFactory::CreateBytesValue(std::string value) {
auto memory_manager = GetMemoryManager();
switch (memory_manager.memory_management()) {
case MemoryManagement::kPooling: {
auto* string = ::new (
memory_manager.Allocate(sizeof(std::string), alignof(std::string)))
std::string(std::move(value));
memory_manager.OwnCustomDestructor(string, &StringDestructor);
return BytesValue{common_internal::ArenaString(*string)};
}
case MemoryManagement::kReferenceCounting: {
auto* refcount = ReferenceCountedString::New(std::move(value));
auto bytes_value = BytesValue{common_internal::SharedByteString(
refcount, absl::string_view(refcount->data(), refcount->size()))};
common_internal::StrongUnref(*refcount);
return bytes_value;
}
}
}
StringValue ValueFactory::CreateUncheckedStringValue(std::string value) {
auto memory_manager = GetMemoryManager();
switch (memory_manager.memory_management()) {
case MemoryManagement::kPooling: {
auto* string = ::new (
memory_manager.Allocate(sizeof(std::string), alignof(std::string)))
std::string(std::move(value));
memory_manager.OwnCustomDestructor(string, &StringDestructor);
return StringValue{common_internal::ArenaString(*string)};
}
case MemoryManagement::kReferenceCounting: {
auto* refcount = ReferenceCountedString::New(std::move(value));
auto string_value = StringValue{common_internal::SharedByteString(
refcount, absl::string_view(refcount->data(), refcount->size()))};
common_internal::StrongUnref(*refcount);
return string_value;
}
}
}
absl::StatusOr<StringValue> ValueFactory::CreateStringValue(std::string value) {
auto [count, ok] = internal::Utf8Validate(value);
if (ABSL_PREDICT_FALSE(!ok)) {
return absl::InvalidArgumentError(
"Illegal byte sequence in UTF-8 encoded string");
}
return CreateUncheckedStringValue(std::move(value));
}
absl::StatusOr<StringValue> ValueFactory::CreateStringValue(absl::Cord value) {
auto [count, ok] = internal::Utf8Validate(value);
if (ABSL_PREDICT_FALSE(!ok)) {
return absl::InvalidArgumentError(
"Illegal byte sequence in UTF-8 encoded string");
}
return StringValue(std::move(value));
}
absl::StatusOr<DurationValue> ValueFactory::CreateDurationValue(
absl::Duration value) {
CEL_RETURN_IF_ERROR(internal::ValidateDuration(value));
return DurationValue{value};
}
absl::StatusOr<TimestampValue> ValueFactory::CreateTimestampValue(
absl::Time value) {
CEL_RETURN_IF_ERROR(internal::ValidateTimestamp(value));
return TimestampValue{value};
}
} | #include "common/value_factory.h"
#include <ostream>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "absl/strings/cord.h"
#include "absl/types/optional.h"
#include "common/casting.h"
#include "common/json.h"
#include "common/memory.h"
#include "common/memory_testing.h"
#include "common/type.h"
#include "common/type_factory.h"
#include "common/type_reflector.h"
#include "common/types/type_cache.h"
#include "common/value.h"
#include "common/value_manager.h"
#include "internal/testing.h"
namespace cel {
namespace {
using common_internal::ProcessLocalTypeCache;
using testing::TestParamInfo;
using testing::TestWithParam;
using testing::UnorderedElementsAreArray;
using cel::internal::IsOkAndHolds;
enum class ThreadSafety {
kCompatible,
kSafe,
};
std::ostream& operator<<(std::ostream& out, ThreadSafety thread_safety) {
switch (thread_safety) {
case ThreadSafety::kCompatible:
return out << "THREAD_SAFE";
case ThreadSafety::kSafe:
return out << "THREAD_COMPATIBLE";
}
}
class ValueFactoryTest
: public common_internal::ThreadCompatibleMemoryTest<ThreadSafety> {
public:
void SetUp() override {
switch (thread_safety()) {
case ThreadSafety::kCompatible:
value_manager_ = NewThreadCompatibleValueManager(
memory_manager(),
NewThreadCompatibleTypeReflector(memory_manager()));
break;
case ThreadSafety::kSafe:
value_manager_ = NewThreadSafeValueManager(
memory_manager(), NewThreadSafeTypeReflector(memory_manager()));
break;
}
}
void TearDown() override { Finish(); }
void Finish() {
value_manager_.reset();
ThreadCompatibleMemoryTest::Finish();
}
TypeFactory& type_factory() const { return value_manager(); }
TypeManager& type_manager() const { return value_manager(); }
ValueFactory& value_factory() const { return value_manager(); }
ValueManager& value_manager() const { return **value_manager_; }
ThreadSafety thread_safety() const { return std::get<1>(GetParam()); }
static std::string ToString(
TestParamInfo<std::tuple<MemoryManagement, ThreadSafety>> param) {
std::ostringstream out;
out << std::get<0>(param.param) << "_" << std::get<1>(param.param);
return out.str();
}
private:
absl::optional<Shared<ValueManager>> value_manager_;
};
TEST_P(ValueFactoryTest, JsonValueNull) {
auto value = value_factory().CreateValueFromJson(kJsonNull);
EXPECT_TRUE(InstanceOf<NullValue>(value));
}
TEST_P(ValueFactoryTest, JsonValueBool) {
auto value = value_factory().CreateValueFromJson(true);
ASSERT_TRUE(InstanceOf<BoolValue>(value));
EXPECT_TRUE(Cast<BoolValue>(value).NativeValue());
}
TEST_P(ValueFactoryTest, JsonValueNumber) {
auto value = value_factory().CreateValueFromJson(1.0);
ASSERT_TRUE(InstanceOf<DoubleValue>(value));
EXPECT_EQ(Cast<DoubleValue>(value).NativeValue(), 1.0);
}
TEST_P(ValueFactoryTest, JsonValueString) {
auto value = value_factory().CreateValueFromJson(absl::Cord("foo"));
ASSERT_TRUE(InstanceOf<StringValue>(value));
EXPECT_EQ(Cast<StringValue>(value).NativeString(), "foo");
}
JsonObject NewJsonObjectForTesting(bool with_array = true,
bool with_nested_object = true);
JsonArray NewJsonArrayForTesting(bool with_nested_array = true,
bool with_object = true) {
JsonArrayBuilder builder;
builder.push_back(kJsonNull);
builder.push_back(true);
builder.push_back(1.0);
builder.push_back(absl::Cord("foo"));
if (with_nested_array) {
builder.push_back(NewJsonArrayForTesting(false, false));
}
if (with_object) {
builder.push_back(NewJsonObjectForTesting(false, false));
}
return std::move(builder).Build();
}
JsonObject NewJsonObjectForTesting(bool with_array, bool with_nested_object) {
JsonObjectBuilder builder;
builder.insert_or_assign(absl::Cord("a"), kJsonNull);
builder.insert_or_assign(absl::Cord("b"), true);
builder.insert_or_assign(absl::Cord("c"), 1.0);
builder.insert_or_assign(absl::Cord("d"), absl::Cord("foo"));
if (with_array) {
builder.insert_or_assign(absl::Cord("e"),
NewJsonArrayForTesting(false, false));
}
if (with_nested_object) {
builder.insert_or_assign(absl::Cord("f"),
NewJsonObjectForTesting(false, false));
}
return std::move(builder).Build();
}
TEST_P(ValueFactoryTest, JsonValueArray) {
auto value = value_factory().CreateValueFromJson(NewJsonArrayForTesting());
ASSERT_TRUE(InstanceOf<ListValue>(value));
EXPECT_EQ(TypeView(value.GetType(type_manager())),
type_factory().GetDynListType());
auto list_value = Cast<ListValue>(value);
EXPECT_THAT(list_value.IsEmpty(), IsOkAndHolds(false));
EXPECT_THAT(list_value.Size(), IsOkAndHolds(6));
EXPECT_EQ(list_value.DebugString(),
"[null, true, 1.0, \"foo\", [null, true, 1.0, \"foo\"], {\"a\": "
"null, \"b\": true, \"c\": 1.0, \"d\": \"foo\"}]");
ASSERT_OK_AND_ASSIGN(auto element, list_value.Get(value_manager(), 0));
EXPECT_TRUE(InstanceOf<NullValue>(element));
}
TEST_P(ValueFactoryTest, JsonValueObject) {
auto value = value_factory().CreateValueFromJson(NewJsonObjectForTesting());
ASSERT_TRUE(InstanceOf<MapValue>(value));
EXPECT_EQ(TypeView(value.GetType(type_manager())),
type_factory().GetStringDynMapType());
auto map_value = Cast<MapValue>(value);
EXPECT_THAT(map_value.IsEmpty(), IsOkAndHolds(false));
EXPECT_THAT(map_value.Size(), IsOkAndHolds(6));
EXPECT_EQ(map_value.DebugString(),
"{\"a\": null, \"b\": true, \"c\": 1.0, \"d\": \"foo\", \"e\": "
"[null, true, 1.0, \"foo\"], \"f\": {\"a\": null, \"b\": true, "
"\"c\": 1.0, \"d\": \"foo\"}}");
ASSERT_OK_AND_ASSIGN(auto keys, map_value.ListKeys(value_manager()));
EXPECT_THAT(keys.Size(), IsOkAndHolds(6));
ASSERT_OK_AND_ASSIGN(auto keys_iterator,
map_value.NewIterator(value_manager()));
std::vector<StringValue> string_keys;
while (keys_iterator->HasNext()) {
ASSERT_OK_AND_ASSIGN(auto key, keys_iterator->Next(value_manager()));
string_keys.push_back(StringValue(Cast<StringValue>(key)));
}
EXPECT_THAT(string_keys, UnorderedElementsAreArray(
{StringValueView("a"), StringValueView("b"),
StringValueView("c"), StringValueView("d"),
StringValueView("e"), StringValueView("f")}));
ASSERT_OK_AND_ASSIGN(auto has,
map_value.Has(value_manager(), StringValueView("a")));
ASSERT_TRUE(InstanceOf<BoolValue>(has));
EXPECT_TRUE(Cast<BoolValue>(has).NativeValue());
ASSERT_OK_AND_ASSIGN(
has, map_value.Has(value_manager(), StringValueView(absl::Cord("a"))));
ASSERT_TRUE(InstanceOf<BoolValue>(has));
EXPECT_TRUE(Cast<BoolValue>(has).NativeValue());
ASSERT_OK_AND_ASSIGN(auto get,
map_value.Get(value_manager(), StringValueView("a")));
ASSERT_TRUE(InstanceOf<NullValue>(get));
ASSERT_OK_AND_ASSIGN(
get, map_value.Get(value_manager(), StringValueView(absl::Cord("a"))));
ASSERT_TRUE(InstanceOf<NullValue>(get));
}
TEST_P(ValueFactoryTest, ListValue) {
auto list_value1 = value_factory().CreateZeroListValue(
type_factory().CreateListType(StringTypeView()));
EXPECT_TRUE(
Is(list_value1, value_factory().CreateZeroListValue(
type_factory().CreateListType(StringTypeView()))));
EXPECT_FALSE(
Is(list_value1, value_factory().CreateZeroListValue(
type_factory().CreateListType(BoolTypeView()))));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto list_value2 = value_factory().CreateZeroListValue(
type_factory().CreateListType(struct_type1));
EXPECT_TRUE(
Is(list_value2, value_factory().CreateZeroListValue(
type_factory().CreateListType(struct_type1))));
EXPECT_FALSE(
Is(list_value2, value_factory().CreateZeroListValue(
type_factory().CreateListType(struct_type2))));
auto zero_list_value = value_factory().GetZeroDynListValue();
EXPECT_THAT(zero_list_value.IsEmpty(), IsOkAndHolds(true));
EXPECT_THAT(zero_list_value.Size(), IsOkAndHolds(0));
EXPECT_EQ(zero_list_value.GetType(type_manager()),
ProcessLocalTypeCache::Get()->GetDynListType());
}
TEST_P(ValueFactoryTest, MapValue) {
auto map_value1 = value_factory().CreateZeroMapValue(
type_factory().CreateMapType(StringTypeView(), IntTypeView()));
EXPECT_TRUE(Is(map_value1, value_factory().CreateZeroMapValue(
type_factory().CreateMapType(StringTypeView(),
IntTypeView()))));
EXPECT_FALSE(Is(map_value1, value_factory().CreateZeroMapValue(
type_factory().CreateMapType(
StringTypeView(), BoolTypeView()))));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto map_value2 = value_factory().CreateZeroMapValue(
type_factory().CreateMapType(StringTypeView(), struct_type1));
EXPECT_TRUE(Is(map_value2, value_factory().CreateZeroMapValue(
type_factory().CreateMapType(StringTypeView(),
struct_type1))));
EXPECT_FALSE(Is(map_value2, value_factory().CreateZeroMapValue(
type_factory().CreateMapType(StringTypeView(),
struct_type2))));
auto zero_map_value = value_factory().GetZeroDynDynMapValue();
EXPECT_THAT(zero_map_value.IsEmpty(), IsOkAndHolds(true));
EXPECT_THAT(zero_map_value.Size(), IsOkAndHolds(0));
EXPECT_EQ(zero_map_value.GetType(type_manager()),
ProcessLocalTypeCache::Get()->GetDynDynMapType());
zero_map_value = value_factory().GetZeroStringDynMapValue();
EXPECT_THAT(zero_map_value.IsEmpty(), IsOkAndHolds(true));
EXPECT_THAT(zero_map_value.Size(), IsOkAndHolds(0));
EXPECT_EQ(zero_map_value.GetType(type_manager()),
ProcessLocalTypeCache::Get()->GetStringDynMapType());
}
TEST_P(ValueFactoryTest, OptionalType) {
auto optional_value1 = value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(StringTypeView()));
EXPECT_TRUE(Is(optional_value1,
value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(StringTypeView()))));
EXPECT_FALSE(Is(optional_value1,
value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(BoolTypeView()))));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto optional_value2 = value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(struct_type1));
EXPECT_TRUE(Is(optional_value2,
value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(struct_type1))));
EXPECT_FALSE(Is(optional_value2,
value_factory().CreateZeroOptionalValue(
type_factory().CreateOptionalType(struct_type2))));
auto zero_optional_value = value_factory().GetZeroDynOptionalValue();
EXPECT_FALSE(zero_optional_value.HasValue());
EXPECT_EQ(zero_optional_value.GetType(type_manager()),
ProcessLocalTypeCache::Get()->GetDynOptionalType());
}
INSTANTIATE_TEST_SUITE_P(
ValueFactoryTest, ValueFactoryTest,
::testing::Combine(::testing::Values(MemoryManagement::kPooling,
MemoryManagement::kReferenceCounting),
::testing::Values(ThreadSafety::kCompatible,
ThreadSafety::kSafe)),
ValueFactoryTest::ToString);
}
} | 1 |
#ifndef THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_VALUE_TESTING_H_
#define THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_VALUE_TESTING_H_
#include <ostream>
#include "absl/status/status.h"
#include "common/value.h"
#include "extensions/protobuf/internal/message.h"
#include "extensions/protobuf/value.h"
#include "internal/testing.h"
namespace cel::extensions::test {
template <typename MessageType>
class StructValueAsProtoMatcher {
public:
using is_gtest_matcher = void;
explicit StructValueAsProtoMatcher(testing::Matcher<MessageType>&& m)
: m_(std::move(m)) {}
bool MatchAndExplain(cel::Value v,
testing::MatchResultListener* result_listener) const {
MessageType msg;
absl::Status s = ProtoMessageFromValue(v, msg);
if (!s.ok()) {
*result_listener << "cannot convert to "
<< MessageType::descriptor()->full_name() << ": " << s;
return false;
}
return m_.MatchAndExplain(msg, result_listener);
}
void DescribeTo(std::ostream* os) const {
*os << "matches proto message " << m_;
}
void DescribeNegationTo(std::ostream* os) const {
*os << "does not match proto message " << m_;
}
private:
testing::Matcher<MessageType> m_;
};
template <typename MessageType>
inline StructValueAsProtoMatcher<MessageType> StructValueAsProto(
testing::Matcher<MessageType>&& m) {
static_assert(
cel::extensions::protobuf_internal::IsProtoMessage<MessageType>);
return StructValueAsProtoMatcher<MessageType>(std::move(m));
}
}
#endif
#include "common/value_testing.h"
#include <cstdint>
#include <ostream>
#include <string>
#include <utility>
#include "gtest/gtest.h"
#include "absl/status/status.h"
#include "absl/time/time.h"
#include "common/casting.h"
#include "common/value.h"
#include "common/value_kind.h"
#include "internal/testing.h"
namespace cel {
void PrintTo(const Value& value, std::ostream* os) { *os << value << "\n"; }
namespace test {
namespace {
using testing::Matcher;
template <typename Type>
constexpr ValueKind ToValueKind() {
if constexpr (std::is_same_v<Type, BoolValue>) {
return ValueKind::kBool;
} else if constexpr (std::is_same_v<Type, IntValue>) {
return ValueKind::kInt;
} else if constexpr (std::is_same_v<Type, UintValue>) {
return ValueKind::kUint;
} else if constexpr (std::is_same_v<Type, DoubleValue>) {
return ValueKind::kDouble;
} else if constexpr (std::is_same_v<Type, StringValue>) {
return ValueKind::kString;
} else if constexpr (std::is_same_v<Type, BytesValue>) {
return ValueKind::kBytes;
} else if constexpr (std::is_same_v<Type, DurationValue>) {
return ValueKind::kDuration;
} else if constexpr (std::is_same_v<Type, TimestampValue>) {
return ValueKind::kTimestamp;
} else if constexpr (std::is_same_v<Type, ErrorValue>) {
return ValueKind::kError;
} else if constexpr (std::is_same_v<Type, MapValue>) {
return ValueKind::kMap;
} else if constexpr (std::is_same_v<Type, ListValue>) {
return ValueKind::kList;
} else if constexpr (std::is_same_v<Type, StructValue>) {
return ValueKind::kStruct;
} else if constexpr (std::is_same_v<Type, OpaqueValue>) {
return ValueKind::kOpaque;
} else {
return ValueKind::kError;
}
}
template <typename Type, typename NativeType>
class SimpleTypeMatcherImpl : public testing::MatcherInterface<const Value&> {
public:
using MatcherType = Matcher<NativeType>;
explicit SimpleTypeMatcherImpl(MatcherType&& matcher)
: matcher_(std::forward<MatcherType>(matcher)) {}
bool MatchAndExplain(const Value& v,
testing::MatchResultListener* listener) const override {
return InstanceOf<Type>(v) &&
matcher_.MatchAndExplain(Cast<Type>(v).NativeValue(), listener);
}
void DescribeTo(std::ostream* os) const override {
*os << absl::StrCat("kind is ", ValueKindToString(ToValueKind<Type>()),
" and ");
matcher_.DescribeTo(os);
}
private:
MatcherType matcher_;
};
template <typename Type>
class StringTypeMatcherImpl : public testing::MatcherInterface<const Value&> {
public:
using MatcherType = Matcher<std::string>;
explicit StringTypeMatcherImpl(MatcherType matcher)
: matcher_((std::move(matcher))) {}
bool MatchAndExplain(const Value& v,
testing::MatchResultListener* listener) const override {
return InstanceOf<Type>(v) && matcher_.Matches(Cast<Type>(v).ToString());
}
void DescribeTo(std::ostream* os) const override {
*os << absl::StrCat("kind is ", ValueKindToString(ToValueKind<Type>()),
" and ");
matcher_.DescribeTo(os);
}
private:
MatcherType matcher_;
};
template <typename Type>
class AbstractTypeMatcherImpl : public testing::MatcherInterface<const Value&> {
public:
using MatcherType = Matcher<Type>;
explicit AbstractTypeMatcherImpl(MatcherType&& matcher)
: matcher_(std::forward<MatcherType>(matcher)) {}
bool MatchAndExplain(const Value& v,
testing::MatchResultListener* listener) const override {
return InstanceOf<Type>(v) && matcher_.Matches(Cast<Type>(v));
}
void DescribeTo(std::ostream* os) const override {
*os << absl::StrCat("kind is ", ValueKindToString(ToValueKind<Type>()),
" and ");
matcher_.DescribeTo(os);
}
private:
MatcherType matcher_;
};
class OptionalValueMatcherImpl
: public testing::MatcherInterface<const Value&> {
public:
explicit OptionalValueMatcherImpl(ValueMatcher matcher)
: matcher_(std::move(matcher)) {}
bool MatchAndExplain(const Value& v,
testing::MatchResultListener* listener) const override {
if (!InstanceOf<OptionalValue>(v)) {
*listener << "wanted OptionalValue, got " << ValueKindToString(v.kind());
return false;
}
const auto& optional_value = Cast<OptionalValue>(v);
if (!optional_value->HasValue()) {
*listener << "OptionalValue is not engaged";
return false;
}
return matcher_.MatchAndExplain(optional_value->Value(), listener);
}
void DescribeTo(std::ostream* os) const override {
*os << "is OptionalValue that is engaged with value whose ";
matcher_.DescribeTo(os);
}
private:
ValueMatcher matcher_;
};
MATCHER(OptionalValueIsEmptyImpl, "is empty OptionalValue") {
const Value& v = arg;
if (!InstanceOf<OptionalValue>(v)) {
*result_listener << "wanted OptionalValue, got "
<< ValueKindToString(v.kind());
return false;
}
const auto& optional_value = Cast<OptionalValue>(v);
*result_listener << (optional_value.HasValue() ? "is not empty" : "is empty");
return !optional_value->HasValue();
}
}
ValueMatcher BoolValueIs(Matcher<bool> m) {
return ValueMatcher(new SimpleTypeMatcherImpl<BoolValue, bool>(std::move(m)));
}
ValueMatcher IntValueIs(Matcher<int64_t> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<IntValue, int64_t>(std::move(m)));
}
ValueMatcher UintValueIs(Matcher<uint64_t> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<UintValue, uint64_t>(std::move(m)));
}
ValueMatcher DoubleValueIs(Matcher<double> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<DoubleValue, double>(std::move(m)));
}
ValueMatcher TimestampValueIs(Matcher<absl::Time> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<TimestampValue, absl::Time>(std::move(m)));
}
ValueMatcher DurationValueIs(Matcher<absl::Duration> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<DurationValue, absl::Duration>(std::move(m)));
}
ValueMatcher ErrorValueIs(Matcher<absl::Status> m) {
return ValueMatcher(
new SimpleTypeMatcherImpl<ErrorValue, absl::Status>(std::move(m)));
}
ValueMatcher StringValueIs(Matcher<std::string> m) {
return ValueMatcher(new StringTypeMatcherImpl<StringValue>(std::move(m)));
}
ValueMatcher BytesValueIs(Matcher<std::string> m) {
return ValueMatcher(new StringTypeMatcherImpl<BytesValue>(std::move(m)));
}
ValueMatcher MapValueIs(Matcher<MapValue> m) {
return ValueMatcher(new AbstractTypeMatcherImpl<MapValue>(std::move(m)));
}
ValueMatcher ListValueIs(Matcher<ListValue> m) {
return ValueMatcher(new AbstractTypeMatcherImpl<ListValue>(std::move(m)));
}
ValueMatcher StructValueIs(Matcher<StructValue> m) {
return ValueMatcher(new AbstractTypeMatcherImpl<StructValue>(std::move(m)));
}
ValueMatcher OptionalValueIs(ValueMatcher m) {
return ValueMatcher(new OptionalValueMatcherImpl(std::move(m)));
}
ValueMatcher OptionalValueIsEmpty() { return OptionalValueIsEmptyImpl(); }
}
} | #include "extensions/protobuf/value_testing.h"
#include "common/memory.h"
#include "common/value.h"
#include "common/value_testing.h"
#include "extensions/protobuf/memory_manager.h"
#include "extensions/protobuf/value.h"
#include "internal/proto_matchers.h"
#include "internal/testing.h"
#include "proto/test/v1/proto2/test_all_types.pb.h"
#include "google/protobuf/arena.h"
namespace cel::extensions::test {
namespace {
using ::cel::extensions::ProtoMessageToValue;
using ::cel::internal::test::EqualsProto;
using ::google::api::expr::test::v1::proto2::TestAllTypes;
class ProtoValueTesting : public common_internal::ThreadCompatibleValueTest<> {
protected:
MemoryManager NewThreadCompatiblePoolingMemoryManager() override {
return cel::extensions::ProtoMemoryManager(&arena_);
}
private:
google::protobuf::Arena arena_;
};
class ProtoValueTestingTest : public ProtoValueTesting {};
TEST_P(ProtoValueTestingTest, StructValueAsProtoSimple) {
TestAllTypes test_proto;
test_proto.set_single_int32(42);
test_proto.set_single_string("foo");
ASSERT_OK_AND_ASSIGN(cel::Value v,
ProtoMessageToValue(value_manager(), test_proto));
EXPECT_THAT(v, StructValueAsProto<TestAllTypes>(EqualsProto(R"pb(
single_int32: 42
single_string: "foo"
)pb")));
}
INSTANTIATE_TEST_SUITE_P(ProtoValueTesting, ProtoValueTestingTest,
testing::Values(MemoryManagement::kPooling,
MemoryManagement::kReferenceCounting),
ProtoValueTestingTest::ToString);
}
} | 2 |
#ifndef THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_TYPE_INTROSPECTOR_H_
#define THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_TYPE_INTROSPECTOR_H_
#include "absl/base/nullability.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "common/type.h"
#include "common/type_factory.h"
#include "common/type_introspector.h"
#include "google/protobuf/descriptor.h"
namespace cel::extensions {
class ProtoTypeIntrospector : public virtual TypeIntrospector {
public:
ProtoTypeIntrospector()
: ProtoTypeIntrospector(google::protobuf::DescriptorPool::generated_pool()) {}
explicit ProtoTypeIntrospector(
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool)
: descriptor_pool_(descriptor_pool) {}
absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool() const {
return descriptor_pool_;
}
protected:
absl::StatusOr<absl::optional<TypeView>> FindTypeImpl(
TypeFactory& type_factory, absl::string_view name,
Type& scratch) const final;
absl::StatusOr<absl::optional<StructTypeFieldView>>
FindStructTypeFieldByNameImpl(TypeFactory& type_factory,
absl::string_view type, absl::string_view name,
StructTypeField& scratch) const final;
private:
absl::Nonnull<const google::protobuf::DescriptorPool*> const descriptor_pool_;
};
}
#endif
#include "extensions/protobuf/type_introspector.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "common/type.h"
#include "common/type_factory.h"
#include "common/type_introspector.h"
#include "extensions/protobuf/type.h"
#include "internal/status_macros.h"
namespace cel::extensions {
absl::StatusOr<absl::optional<TypeView>> ProtoTypeIntrospector::FindTypeImpl(
TypeFactory& type_factory, absl::string_view name, Type& scratch) const {
const auto* desc = descriptor_pool()->FindMessageTypeByName(name);
if (desc == nullptr) {
return absl::nullopt;
}
scratch = type_factory.CreateStructType(desc->full_name());
return scratch;
}
absl::StatusOr<absl::optional<StructTypeFieldView>>
ProtoTypeIntrospector::FindStructTypeFieldByNameImpl(
TypeFactory& type_factory, absl::string_view type, absl::string_view name,
StructTypeField& scratch) const {
const auto* desc = descriptor_pool()->FindMessageTypeByName(type);
if (desc == nullptr) {
return absl::nullopt;
}
const auto* field_desc = desc->FindFieldByName(name);
if (field_desc == nullptr) {
field_desc = descriptor_pool()->FindExtensionByPrintableName(desc, name);
if (field_desc == nullptr) {
return absl::nullopt;
}
}
StructTypeFieldView result;
CEL_ASSIGN_OR_RETURN(
result.type,
ProtoFieldTypeToType(type_factory, field_desc, scratch.type));
result.name = field_desc->name();
result.number = field_desc->number();
return result;
}
} | #include "extensions/protobuf/type_introspector.h"
#include "absl/types/optional.h"
#include "common/type.h"
#include "common/type_testing.h"
#include "internal/testing.h"
#include "proto/test/v1/proto2/test_all_types.pb.h"
#include "google/protobuf/descriptor.h"
namespace cel::extensions {
namespace {
using ::google::api::expr::test::v1::proto2::TestAllTypes;
using testing::Eq;
using testing::Optional;
using cel::internal::IsOkAndHolds;
class ProtoTypeIntrospectorTest
: public common_internal::ThreadCompatibleTypeTest<> {
private:
Shared<TypeIntrospector> NewTypeIntrospector(
MemoryManagerRef memory_manager) override {
return memory_manager.MakeShared<ProtoTypeIntrospector>();
}
};
TEST_P(ProtoTypeIntrospectorTest, FindType) {
EXPECT_THAT(
type_manager().FindType(TestAllTypes::descriptor()->full_name()),
IsOkAndHolds(Optional(Eq(StructType(
memory_manager(), TestAllTypes::GetDescriptor()->full_name())))));
EXPECT_THAT(type_manager().FindType("type.that.does.not.Exist"),
IsOkAndHolds(Eq(absl::nullopt)));
}
TEST_P(ProtoTypeIntrospectorTest, FindStructTypeFieldByName) {
ASSERT_OK_AND_ASSIGN(
auto field, type_manager().FindStructTypeFieldByName(
TestAllTypes::descriptor()->full_name(), "single_int32"));
ASSERT_TRUE(field.has_value());
EXPECT_THAT(field->name, Eq("single_int32"));
EXPECT_THAT(field->number, Eq(1));
EXPECT_THAT(field->type, Eq(IntType{}));
EXPECT_THAT(
type_manager().FindStructTypeFieldByName(
TestAllTypes::descriptor()->full_name(), "field_that_does_not_exist"),
IsOkAndHolds(Eq(absl::nullopt)));
EXPECT_THAT(type_manager().FindStructTypeFieldByName(
"type.that.does.not.Exist", "does_not_matter"),
IsOkAndHolds(Eq(absl::nullopt)));
}
INSTANTIATE_TEST_SUITE_P(
ProtoTypeIntrospectorTest, ProtoTypeIntrospectorTest,
::testing::Values(MemoryManagement::kPooling,
MemoryManagement::kReferenceCounting),
ProtoTypeIntrospectorTest::ToString);
}
} | 3 |
#ifndef THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_INTERNAL_CONSTANT_H_
#define THIRD_PARTY_CEL_CPP_EXTENSIONS_PROTOBUF_INTERNAL_CONSTANT_H_
#include "google/api/expr/v1alpha1/syntax.pb.h"
#include "absl/base/nullability.h"
#include "absl/status/status.h"
#include "common/constant.h"
namespace cel::extensions::protobuf_internal {
absl::Status ConstantToProto(const Constant& constant,
absl::Nonnull<google::api::expr::v1alpha1::Constant*> proto);
absl::Status ConstantFromProto(const google::api::expr::v1alpha1::Constant& proto,
Constant& constant);
}
#endif
#include "extensions/protobuf/internal/constant.h"
#include <cstddef>
#include <cstdint>
#include "google/api/expr/v1alpha1/syntax.pb.h"
#include "google/protobuf/struct.pb.h"
#include "absl/base/nullability.h"
#include "absl/functional/overload.h"
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/time/time.h"
#include "absl/types/variant.h"
#include "common/constant.h"
#include "internal/proto_time_encoding.h"
namespace cel::extensions::protobuf_internal {
using ConstantProto = google::api::expr::v1alpha1::Constant;
absl::Status ConstantToProto(const Constant& constant,
absl::Nonnull<ConstantProto*> proto) {
return absl::visit(absl::Overload(
[proto](absl::monostate) -> absl::Status {
proto->clear_constant_kind();
return absl::OkStatus();
},
[proto](std::nullptr_t) -> absl::Status {
proto->set_null_value(google::protobuf::NULL_VALUE);
return absl::OkStatus();
},
[proto](bool value) -> absl::Status {
proto->set_bool_value(value);
return absl::OkStatus();
},
[proto](int64_t value) -> absl::Status {
proto->set_int64_value(value);
return absl::OkStatus();
},
[proto](uint64_t value) -> absl::Status {
proto->set_uint64_value(value);
return absl::OkStatus();
},
[proto](double value) -> absl::Status {
proto->set_double_value(value);
return absl::OkStatus();
},
[proto](const BytesConstant& value) -> absl::Status {
proto->set_bytes_value(value);
return absl::OkStatus();
},
[proto](const StringConstant& value) -> absl::Status {
proto->set_string_value(value);
return absl::OkStatus();
},
[proto](absl::Duration value) -> absl::Status {
return internal::EncodeDuration(
value, proto->mutable_duration_value());
},
[proto](absl::Time value) -> absl::Status {
return internal::EncodeTime(
value, proto->mutable_timestamp_value());
}),
constant.kind());
}
absl::Status ConstantFromProto(const ConstantProto& proto, Constant& constant) {
switch (proto.constant_kind_case()) {
case ConstantProto::CONSTANT_KIND_NOT_SET:
constant = Constant{};
break;
case ConstantProto::kNullValue:
constant.set_null_value();
break;
case ConstantProto::kBoolValue:
constant.set_bool_value(proto.bool_value());
break;
case ConstantProto::kInt64Value:
constant.set_int_value(proto.int64_value());
break;
case ConstantProto::kUint64Value:
constant.set_uint_value(proto.uint64_value());
break;
case ConstantProto::kDoubleValue:
constant.set_double_value(proto.double_value());
break;
case ConstantProto::kStringValue:
constant.set_string_value(proto.string_value());
break;
case ConstantProto::kBytesValue:
constant.set_bytes_value(proto.bytes_value());
break;
case ConstantProto::kDurationValue:
constant.set_duration_value(
internal::DecodeDuration(proto.duration_value()));
break;
case ConstantProto::kTimestampValue:
constant.set_timestamp_value(
internal::DecodeTime(proto.timestamp_value()));
break;
default:
return absl::InvalidArgumentError(
absl::StrCat("unexpected ConstantKindCase: ",
static_cast<int>(proto.constant_kind_case())));
}
return absl::OkStatus();
}
} | #include "common/constant.h"
#include <cmath>
#include <string>
#include "absl/strings/has_absl_stringify.h"
#include "absl/strings/str_format.h"
#include "absl/time/time.h"
#include "internal/testing.h"
namespace cel {
namespace {
using testing::IsEmpty;
using testing::IsFalse;
using testing::IsTrue;
TEST(Constant, NullValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_null_value(), IsFalse());
const_expr.set_null_value();
EXPECT_THAT(const_expr.has_null_value(), IsTrue());
}
TEST(Constant, BoolValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_bool_value(), IsFalse());
EXPECT_EQ(const_expr.bool_value(), false);
const_expr.set_bool_value(false);
EXPECT_THAT(const_expr.has_bool_value(), IsTrue());
EXPECT_EQ(const_expr.bool_value(), false);
}
TEST(Constant, IntValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_int_value(), IsFalse());
EXPECT_EQ(const_expr.int_value(), 0);
const_expr.set_int_value(0);
EXPECT_THAT(const_expr.has_int_value(), IsTrue());
EXPECT_EQ(const_expr.int_value(), 0);
}
TEST(Constant, UintValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_uint_value(), IsFalse());
EXPECT_EQ(const_expr.uint_value(), 0);
const_expr.set_uint_value(0);
EXPECT_THAT(const_expr.has_uint_value(), IsTrue());
EXPECT_EQ(const_expr.uint_value(), 0);
}
TEST(Constant, DoubleValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_double_value(), IsFalse());
EXPECT_EQ(const_expr.double_value(), 0);
const_expr.set_double_value(0);
EXPECT_THAT(const_expr.has_double_value(), IsTrue());
EXPECT_EQ(const_expr.double_value(), 0);
}
TEST(Constant, BytesValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_bytes_value(), IsFalse());
EXPECT_THAT(const_expr.bytes_value(), IsEmpty());
const_expr.set_bytes_value("foo");
EXPECT_THAT(const_expr.has_bytes_value(), IsTrue());
EXPECT_EQ(const_expr.bytes_value(), "foo");
}
TEST(Constant, StringValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_string_value(), IsFalse());
EXPECT_THAT(const_expr.string_value(), IsEmpty());
const_expr.set_string_value("foo");
EXPECT_THAT(const_expr.has_string_value(), IsTrue());
EXPECT_EQ(const_expr.string_value(), "foo");
}
TEST(Constant, DurationValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_duration_value(), IsFalse());
EXPECT_EQ(const_expr.duration_value(), absl::ZeroDuration());
const_expr.set_duration_value(absl::ZeroDuration());
EXPECT_THAT(const_expr.has_duration_value(), IsTrue());
EXPECT_EQ(const_expr.duration_value(), absl::ZeroDuration());
}
TEST(Constant, TimestampValue) {
Constant const_expr;
EXPECT_THAT(const_expr.has_timestamp_value(), IsFalse());
EXPECT_EQ(const_expr.timestamp_value(), absl::UnixEpoch());
const_expr.set_timestamp_value(absl::UnixEpoch());
EXPECT_THAT(const_expr.has_timestamp_value(), IsTrue());
EXPECT_EQ(const_expr.timestamp_value(), absl::UnixEpoch());
}
TEST(Constant, Equality) {
EXPECT_EQ(Constant{}, Constant{});
Constant lhs_const_expr;
Constant rhs_const_expr;
lhs_const_expr.set_null_value();
rhs_const_expr.set_null_value();
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_bool_value(false);
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_bool_value(false);
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_int_value(0);
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_int_value(0);
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_uint_value(0);
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_uint_value(0);
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_double_value(0);
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_double_value(0);
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_bytes_value("foo");
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_bytes_value("foo");
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_string_value("foo");
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_string_value("foo");
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_duration_value(absl::ZeroDuration());
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_duration_value(absl::ZeroDuration());
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
lhs_const_expr.set_timestamp_value(absl::UnixEpoch());
rhs_const_expr.set_null_value();
EXPECT_NE(lhs_const_expr, rhs_const_expr);
EXPECT_NE(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
rhs_const_expr.set_timestamp_value(absl::UnixEpoch());
EXPECT_EQ(lhs_const_expr, rhs_const_expr);
EXPECT_EQ(rhs_const_expr, lhs_const_expr);
EXPECT_NE(lhs_const_expr, Constant{});
EXPECT_NE(Constant{}, rhs_const_expr);
}
std::string Stringify(const Constant& constant) {
return absl::StrFormat("%v", constant);
}
TEST(Constant, HasAbslStringify) {
EXPECT_TRUE(absl::HasAbslStringify<Constant>::value);
}
TEST(Constant, AbslStringify) {
Constant constant;
EXPECT_EQ(Stringify(constant), "<unspecified>");
constant.set_null_value();
EXPECT_EQ(Stringify(constant), "null");
constant.set_bool_value(true);
EXPECT_EQ(Stringify(constant), "true");
constant.set_int_value(1);
EXPECT_EQ(Stringify(constant), "1");
constant.set_uint_value(1);
EXPECT_EQ(Stringify(constant), "1u");
constant.set_double_value(1);
EXPECT_EQ(Stringify(constant), "1.0");
constant.set_double_value(1.1);
EXPECT_EQ(Stringify(constant), "1.1");
constant.set_double_value(NAN);
EXPECT_EQ(Stringify(constant), "nan");
constant.set_double_value(INFINITY);
EXPECT_EQ(Stringify(constant), "+infinity");
constant.set_double_value(-INFINITY);
EXPECT_EQ(Stringify(constant), "-infinity");
constant.set_bytes_value("foo");
EXPECT_EQ(Stringify(constant), "b\"foo\"");
constant.set_string_value("foo");
EXPECT_EQ(Stringify(constant), "\"foo\"");
constant.set_duration_value(absl::Seconds(1));
EXPECT_EQ(Stringify(constant), "duration(\"1s\")");
constant.set_timestamp_value(absl::UnixEpoch() + absl::Seconds(1));
EXPECT_EQ(Stringify(constant), "timestamp(\"1970-01-01T00:00:01Z\")");
}
}
} | 4 |
#ifndef THIRD_PARTY_CEL_CPP_BASE_AST_INTERNAL_EXPR_H_
#define THIRD_PARTY_CEL_CPP_BASE_AST_INTERNAL_EXPR_H_
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "absl/container/flat_hash_map.h"
#include "absl/types/optional.h"
#include "absl/types/variant.h"
#include "common/ast.h"
#include "common/constant.h"
#include "common/expr.h"
namespace cel::ast_internal {
using NullValue = std::nullptr_t;
using Bytes = cel::BytesConstant;
using Constant = cel::Constant;
using ConstantKind = cel::ConstantKind;
using Ident = cel::IdentExpr;
using Expr = cel::Expr;
using ExprKind = cel::ExprKind;
using Select = cel::SelectExpr;
using Call = cel::CallExpr;
using CreateList = cel::ListExpr;
using CreateStruct = cel::StructExpr;
using Comprehension = cel::ComprehensionExpr;
class Extension {
public:
class Version {
public:
Version() : major_(0), minor_(0) {}
Version(int64_t major, int64_t minor) : major_(major), minor_(minor) {}
Version(const Version& other) = default;
Version(Version&& other) = default;
Version& operator=(const Version& other) = default;
Version& operator=(Version&& other) = default;
static const Version& DefaultInstance();
int64_t major() const { return major_; }
void set_major(int64_t val) { major_ = val; }
int64_t minor() const { return minor_; }
void set_minor(int64_t val) { minor_ = val; }
bool operator==(const Version& other) const {
return major_ == other.major_ && minor_ == other.minor_;
}
bool operator!=(const Version& other) const { return !operator==(other); }
private:
int64_t major_;
int64_t minor_;
};
enum class Component {
kUnspecified,
kParser,
kTypeChecker,
kRuntime
};
static const Extension& DefaultInstance();
Extension() = default;
Extension(std::string id, std::unique_ptr<Version> version,
std::vector<Component> affected_components)
: id_(std::move(id)),
affected_components_(std::move(affected_components)),
version_(std::move(version)) {}
Extension(const Extension& other);
Extension(Extension&& other) = default;
Extension& operator=(const Extension& other);
Extension& operator=(Extension&& other) = default;
const std::string& id() const { return id_; }
void set_id(std::string id) { id_ = std::move(id); }
const std::vector<Component>& affected_components() const {
return affected_components_;
}
std::vector<Component>& mutable_affected_components() {
return affected_components_;
}
const Version& version() const {
if (version_ == nullptr) {
return Version::DefaultInstance();
}
return *version_;
}
Version& mutable_version() {
if (version_ == nullptr) {
version_ = std::make_unique<Version>();
}
return *version_;
}
void set_version(std::unique_ptr<Version> version) {
version_ = std::move(version);
}
bool operator==(const Extension& other) const {
return id_ == other.id_ &&
affected_components_ == other.affected_components_ &&
version() == other.version();
}
bool operator!=(const Extension& other) const { return !operator==(other); }
private:
std::string id_;
std::vector<Component> affected_components_;
std::unique_ptr<Version> version_;
};
class SourceInfo {
public:
SourceInfo() = default;
SourceInfo(std::string syntax_version, std::string location,
std::vector<int32_t> line_offsets,
absl::flat_hash_map<int64_t, int32_t> positions,
absl::flat_hash_map<int64_t, Expr> macro_calls,
std::vector<Extension> extensions)
: syntax_version_(std::move(syntax_version)),
location_(std::move(location)),
line_offsets_(std::move(line_offsets)),
positions_(std::move(positions)),
macro_calls_(std::move(macro_calls)),
extensions_(std::move(extensions)) {}
void set_syntax_version(std::string syntax_version) {
syntax_version_ = std::move(syntax_version);
}
void set_location(std::string location) { location_ = std::move(location); }
void set_line_offsets(std::vector<int32_t> line_offsets) {
line_offsets_ = std::move(line_offsets);
}
void set_positions(absl::flat_hash_map<int64_t, int32_t> positions) {
positions_ = std::move(positions);
}
void set_macro_calls(absl::flat_hash_map<int64_t, Expr> macro_calls) {
macro_calls_ = std::move(macro_calls);
}
const std::string& syntax_version() const { return syntax_version_; }
const std::string& location() const { return location_; }
const std::vector<int32_t>& line_offsets() const { return line_offsets_; }
std::vector<int32_t>& mutable_line_offsets() { return line_offsets_; }
const absl::flat_hash_map<int64_t, int32_t>& positions() const {
return positions_;
}
absl::flat_hash_map<int64_t, int32_t>& mutable_positions() {
return positions_;
}
const absl::flat_hash_map<int64_t, Expr>& macro_calls() const {
return macro_calls_;
}
absl::flat_hash_map<int64_t, Expr>& mutable_macro_calls() {
return macro_calls_;
}
bool operator==(const SourceInfo& other) const {
return syntax_version_ == other.syntax_version_ &&
location_ == other.location_ &&
line_offsets_ == other.line_offsets_ &&
positions_ == other.positions_ &&
macro_calls_ == other.macro_calls_ &&
extensions_ == other.extensions_;
}
bool operator!=(const SourceInfo& other) const { return !operator==(other); }
const std::vector<Extension>& extensions() const { return extensions_; }
std::vector<Extension>& mutable_extensions() { return extensions_; }
private:
std::string syntax_version_;
std::string location_;
std::vector<int32_t> line_offsets_;
absl::flat_hash_map<int64_t, int32_t> positions_;
absl::flat_hash_map<int64_t, Expr> macro_calls_;
std::vector<Extension> extensions_;
};
class ParsedExpr {
public:
ParsedExpr() = default;
ParsedExpr(Expr expr, SourceInfo source_info)
: expr_(std::move(expr)), source_info_(std::move(source_info)) {}
ParsedExpr(ParsedExpr&& rhs) = default;
ParsedExpr& operator=(ParsedExpr&& rhs) = default;
void set_expr(Expr expr) { expr_ = std::move(expr); }
void set_source_info(SourceInfo source_info) {
source_info_ = std::move(source_info);
}
const Expr& expr() const { return expr_; }
Expr& mutable_expr() { return expr_; }
const SourceInfo& source_info() const { return source_info_; }
SourceInfo& mutable_source_info() { return source_info_; }
private:
Expr expr_;
SourceInfo source_info_;
};
enum class PrimitiveType {
kPrimitiveTypeUnspecified = 0,
kBool = 1,
kInt64 = 2,
kUint64 = 3,
kDouble = 4,
kString = 5,
kBytes = 6,
};
enum class WellKnownType {
kWellKnownTypeUnspecified = 0,
kAny = 1,
kTimestamp = 2,
kDuration = 3,
};
class Type;
class ListType {
public:
ListType() = default;
ListType(const ListType& rhs)
: elem_type_(std::make_unique<Type>(rhs.elem_type())) {}
ListType& operator=(const ListType& rhs) {
elem_type_ = std::make_unique<Type>(rhs.elem_type());
return *this;
}
ListType(ListType&& rhs) = default;
ListType& operator=(ListType&& rhs) = default;
explicit ListType(std::unique_ptr<Type> elem_type)
: elem_type_(std::move(elem_type)) {}
void set_elem_type(std::unique_ptr<Type> elem_type) {
elem_type_ = std::move(elem_type);
}
bool has_elem_type() const { return elem_type_ != nullptr; }
const Type& elem_type() const;
Type& mutable_elem_type() {
if (elem_type_ == nullptr) {
elem_type_ = std::make_unique<Type>();
}
return *elem_type_;
}
bool operator==(const ListType& other) const;
private:
std::unique_ptr<Type> elem_type_;
};
class MapType {
public:
MapType() = default;
MapType(std::unique_ptr<Type> key_type, std::unique_ptr<Type> value_type)
: key_type_(std::move(key_type)), value_type_(std::move(value_type)) {}
MapType(const MapType& rhs)
: key_type_(std::make_unique<Type>(rhs.key_type())),
value_type_(std::make_unique<Type>(rhs.value_type())) {}
MapType& operator=(const MapType& rhs) {
key_type_ = std::make_unique<Type>(rhs.key_type());
value_type_ = std::make_unique<Type>(rhs.value_type());
return *this;
}
MapType(MapType&& rhs) = default;
MapType& operator=(MapType&& rhs) = default;
void set_key_type(std::unique_ptr<Type> key_type) {
key_type_ = std::move(key_type);
}
void set_value_type(std::unique_ptr<Type> value_type) {
value_type_ = std::move(value_type);
}
bool has_key_type() const { return key_type_ != nullptr; }
bool has_value_type() const { return value_type_ != nullptr; }
const Type& key_type() const;
const Type& value_type() const;
bool operator==(const MapType& other) const;
Type& mutable_key_type() {
if (key_type_ == nullptr) {
key_type_ = std::make_unique<Type>();
}
return *key_type_;
}
Type& mutable_value_type() {
if (value_type_ == nullptr) {
value_type_ = std::make_unique<Type>();
}
return *value_type_;
}
private:
std::unique_ptr<Type> key_type_;
std::unique_ptr<Type> value_type_;
};
class FunctionType {
public:
FunctionType() = default;
FunctionType(std::unique_ptr<Type> result_type, std::vector<Type> arg_types);
FunctionType(const FunctionType& other);
FunctionType& operator=(const FunctionType& other);
FunctionType(FunctionType&&) = default;
FunctionType& operator=(FunctionType&&) = default;
void set_result_type(std::unique_ptr<Type> result_type) {
result_type_ = std::move(result_type);
}
void set_arg_types(std::vector<Type> arg_types);
bool has_result_type() const { return result_type_ != nullptr; }
const Type& result_type() const;
Type& mutable_result_type() {
if (result_type_ == nullptr) {
result_type_ = std::make_unique<Type>();
}
return *result_type_;
}
const std::vector<Type>& arg_types() const { return arg_types_; }
std::vector<Type>& mutable_arg_types() { return arg_types_; }
bool operator==(const FunctionType& other) const;
private:
std::unique_ptr<Type> result_type_;
std::vector<Type> arg_types_;
};
class AbstractType {
public:
AbstractType() = default;
AbstractType(std::string name, std::vector<Type> parameter_types);
void set_name(std::string name) { name_ = std::move(name); }
void set_parameter_types(std::vector<Type> parameter_types);
const std::string& name() const { return name_; }
const std::vector<Type>& parameter_types() const { return parameter_types_; }
std::vector<Type>& mutable_parameter_types() { return parameter_types_; }
bool operator==(const AbstractType& other) const;
private:
std::string name_;
std::vector<Type> parameter_types_;
};
class PrimitiveTypeWrapper {
public:
explicit PrimitiveTypeWrapper(PrimitiveType type) : type_(std::move(type)) {}
void set_type(PrimitiveType type) { type_ = std::move(type); }
const PrimitiveType& type() const { return type_; }
PrimitiveType& mutable_type() { return type_; }
bool operator==(const PrimitiveTypeWrapper& other) const {
return type_ == other.type_;
}
private:
PrimitiveType type_;
};
class MessageType {
public:
MessageType() = default;
explicit MessageType(std::string type) : type_(std::move(type)) {}
void set_type(std::string type) { type_ = std::move(type); }
const std::string& type() const { return type_; }
bool operator==(const MessageType& other) const {
return type_ == other.type_;
}
private:
std::string type_;
};
class ParamType {
public:
ParamType() = default;
explicit ParamType(std::string type) : type_(std::move(type)) {}
void set_type(std::string type) { type_ = std::move(type); }
const std::string& type() const { return type_; }
bool operator==(const ParamType& other) const { return type_ == other.type_; }
private:
std::string type_;
};
enum class ErrorType { kErrorTypeValue = 0 };
using DynamicType = absl::monostate;
using TypeKind =
absl::variant<DynamicType, NullValue, PrimitiveType, PrimitiveTypeWrapper,
WellKnownType, ListType, MapType, FunctionType, MessageType,
ParamType, std::unique_ptr<Type>, ErrorType, AbstractType>;
class Type {
public:
Type() = default;
explicit Type(TypeKind type_kind) : type_kind_(std::move(type_kind)) {}
Type(const Type& other);
Type& operator=(const Type& other);
Type(Type&&) = default;
Type& operator=(Type&&) = default;
void set_type_kind(TypeKind type_kind) { type_kind_ = std::move(type_kind); }
const TypeKind& type_kind() const { return type_kind_; }
TypeKind& mutable_type_kind() { return type_kind_; }
bool has_dyn() const {
return absl::holds_alternative<DynamicType>(type_kind_);
}
bool has_null() const {
return absl::holds_alternative<NullValue>(type_kind_);
}
bool has_primitive() const {
return absl::holds_alternative<PrimitiveType>(type_kind_);
}
bool has_wrapper() const {
return absl::holds_alternative<PrimitiveTypeWrapper>(type_kind_);
}
bool has_well_known() const {
return absl::holds_alternative<WellKnownType>(type_kind_);
}
bool has_list_type() const {
return absl::holds_alternative<ListType>(type_kind_);
}
bool has_map_type() const {
return absl::holds_alternative<MapType>(type_kind_);
}
bool has_function() const {
return absl::holds_alternative<FunctionType>(type_kind_);
}
bool has_message_type() const {
return absl::holds_alternative<MessageType>(type_kind_);
}
bool has_type_param() const {
return absl::holds_alternative<ParamType>(type_kind_);
}
bool has_type() const {
return absl::holds_alternative<std::unique_ptr<Type>>(type_kind_);
}
bool has_error() const {
return absl::holds_alternative<ErrorType>(type_kind_);
}
bool has_abstract_type() const {
return absl::holds_alternative<AbstractType>(type_kind_);
}
NullValue null() const {
auto* value = absl::get_if<NullValue>(&type_kind_);
if (value != nullptr) {
return *value;
}
return nullptr;
}
PrimitiveType primitive() const {
auto* value = absl::get_if<PrimitiveType>(&type_kind_);
if (value != nullptr) {
return *value;
}
return PrimitiveType::kPrimitiveTypeUnspecified;
}
PrimitiveType wrapper() const {
auto* value = absl::get_if<PrimitiveTypeWrapper>(&type_kind_);
if (value != nullptr) {
return value->type();
}
return PrimitiveType::kPrimitiveTypeUnspecified;
}
WellKnownType well_known() const {
auto* value = absl::get_if<WellKnownType>(&type_kind_);
if (value != nullptr) {
return *value;
}
return WellKnownType::kWellKnownTypeUnspecified;
}
const ListType& list_type() const {
auto* value = absl::get_if<ListType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const ListType* default_list_type = new ListType();
return *default_list_type;
}
const MapType& map_type() const {
auto* value = absl::get_if<MapType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const MapType* default_map_type = new MapType();
return *default_map_type;
}
const FunctionType& function() const {
auto* value = absl::get_if<FunctionType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const FunctionType* default_function_type = new FunctionType();
return *default_function_type;
}
const MessageType& message_type() const {
auto* value = absl::get_if<MessageType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const MessageType* default_message_type = new MessageType();
return *default_message_type;
}
const ParamType& type_param() const {
auto* value = absl::get_if<ParamType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const ParamType* default_param_type = new ParamType();
return *default_param_type;
}
const Type& type() const;
ErrorType error_type() const {
auto* value = absl::get_if<ErrorType>(&type_kind_);
if (value != nullptr) {
return *value;
}
return ErrorType::kErrorTypeValue;
}
const AbstractType& abstract_type() const {
auto* value = absl::get_if<AbstractType>(&type_kind_);
if (value != nullptr) {
return *value;
}
static const AbstractType* default_abstract_type = new AbstractType();
return *default_abstract_type;
}
bool operator==(const Type& other) const {
return type_kind_ == other.type_kind_;
}
private:
TypeKind type_kind_;
};
class Reference {
public:
Reference() = default;
Reference(std::string name, std::vector<std::string> overload_id,
Constant value)
: name_(std::move(name)),
overload_id_(std::move(overload_id)),
value_(std::move(value)) {}
void set_name(std::string name) { name_ = std::move(name); }
void set_overload_id(std::vector<std::string> overload_id) {
overload_id_ = std::move(overload_id);
}
void set_value(Constant value) { value_ = std::move(value); }
const std::string& name() const { return name_; }
const std::vector<std::string>& overload_id() const { return overload_id_; }
const Constant& value() const {
if (value_.has_value()) {
return value_.value();
}
static const Constant* default_constant = new Constant;
return *default_constant;
}
std::vector<std::string>& mutable_overload_id() { return overload_id_; }
Constant& mutable_value() {
if (!value_.has_value()) {
value_.emplace();
}
return *value_;
}
bool has_value() const { return value_.has_value(); }
bool operator==(const Reference& other) const {
return name_ == other.name_ && overload_id_ == other.overload_id_ &&
value() == other.value();
}
private:
std::string name_;
std::vector<std::string> overload_id_;
absl::optional<Constant> value_;
};
class CheckedExpr {
public:
CheckedExpr() = default;
CheckedExpr(absl::flat_hash_map<int64_t, Reference> reference_map,
absl::flat_hash_map<int64_t, Type> type_map,
SourceInfo source_info, std::string expr_version, Expr expr)
: reference_map_(std::move(reference_map)),
type_map_(std::move(type_map)),
source_info_(std::move(source_info)),
expr_version_(std::move(expr_version)),
expr_(std::move(expr)) {}
CheckedExpr(CheckedExpr&& rhs) = default;
CheckedExpr& operator=(CheckedExpr&& rhs) = default;
void set_reference_map(
absl::flat_hash_map<int64_t, Reference> reference_map) {
reference_map_ = std::move(reference_map);
}
void set_type_map(absl::flat_hash_map<int64_t, Type> type_map) {
type_map_ = std::move(type_map);
}
void set_source_info(SourceInfo source_info) {
source_info_ = std::move(source_info);
}
void set_expr_version(std::string expr_version) {
expr_version_ = std::move(expr_version);
}
void set_expr(Expr expr) { expr_ = std::move(expr); }
const absl::flat_hash_map<int64_t, Reference>& reference_map() const {
return reference_map_;
}
absl::flat_hash_map<int64_t, Reference>& mutable_reference_map() {
return reference_map_;
}
const absl::flat_hash_map<int64_t, Type>& type_map() const {
return type_map_;
}
absl::flat_hash_map<int64_t, Type>& mutable_type_map() { return type_map_; }
const SourceInfo& source_info() const { return source_info_; }
SourceInfo& mutable_source_info() { return source_info_; }
const std::string& expr_version() const { return expr_version_; }
std::string& mutable_expr_version() { return expr_version_; }
const Expr& expr() const { return expr_; }
Expr& mutable_expr() { return expr_; }
private:
absl::flat_hash_map<int64_t, Reference> reference_map_;
absl::flat_hash_map<int64_t, Type> type_map_;
SourceInfo source_info_;
std::string expr_version_;
Expr expr_;
};
inline FunctionType::FunctionType(std::unique_ptr<Type> result_type,
std::vector<Type> arg_types)
: result_type_(std::move(result_type)), arg_types_(std::move(arg_types)) {}
inline void FunctionType::set_arg_types(std::vector<Type> arg_types) {
arg_types_ = std::move(arg_types);
}
inline AbstractType::AbstractType(std::string name,
std::vector<Type> parameter_types)
: name_(std::move(name)), parameter_types_(std::move(parameter_types)) {}
inline void AbstractType::set_parameter_types(
std::vector<Type> parameter_types) {
parameter_types_ = std::move(parameter_types);
}
inline bool AbstractType::operator==(const AbstractType& other) const {
return name_ == other.name_ && parameter_types_ == other.parameter_types_;
}
}
#endif
#include "base/ast_internal/expr.h"
#include <memory>
#include <vector>
#include "absl/base/no_destructor.h"
#include "absl/functional/overload.h"
#include "absl/types/variant.h"
namespace cel::ast_internal {
namespace {
const Type& default_type() {
static absl::NoDestructor<Type> type;
return *type;
}
TypeKind CopyImpl(const TypeKind& other) {
return absl::visit(absl::Overload(
[](const std::unique_ptr<Type>& other) -> TypeKind {
return std::make_unique<Type>(*other);
},
[](const auto& other) -> TypeKind {
return other;
}),
other);
}
}
const Extension::Version& Extension::Version::DefaultInstance() {
static absl::NoDestructor<Version> instance;
return *instance;
}
const Extension& Extension::DefaultInstance() {
static absl::NoDestructor<Extension> instance;
return *instance;
}
Extension::Extension(const Extension& other)
: id_(other.id_),
affected_components_(other.affected_components_),
version_(std::make_unique<Version>(*other.version_)) {}
Extension& Extension::operator=(const Extension& other) {
id_ = other.id_;
affected_components_ = other.affected_components_;
version_ = std::make_unique<Version>(*other.version_);
return *this;
}
const Type& ListType::elem_type() const {
if (elem_type_ != nullptr) {
return *elem_type_;
}
return default_type();
}
bool ListType::operator==(const ListType& other) const {
return elem_type() == other.elem_type();
}
const Type& MapType::key_type() const {
if (key_type_ != nullptr) {
return *key_type_;
}
return default_type();
}
const Type& MapType::value_type() const {
if (value_type_ != nullptr) {
return *value_type_;
}
return default_type();
}
bool MapType::operator==(const MapType& other) const {
return key_type() == other.key_type() && value_type() == other.value_type();
}
const Type& FunctionType::result_type() const {
if (result_type_ != nullptr) {
return *result_type_;
}
return default_type();
}
bool FunctionType::operator==(const FunctionType& other) const {
return result_type() == other.result_type() && arg_types_ == other.arg_types_;
}
const Type& Type::type() const {
auto* v | #include "base/ast_internal/expr.h"
#include <memory>
#include <string>
#include <utility>
#include "absl/types/variant.h"
#include "common/ast.h"
#include "internal/testing.h"
namespace cel {
namespace ast_internal {
namespace {
TEST(AstTest, ParsedExpr) {
ParsedExpr parsed_expr;
auto& expr = parsed_expr.mutable_expr();
expr.set_id(1);
expr.mutable_ident_expr().set_name("name");
auto& source_info = parsed_expr.mutable_source_info();
source_info.set_syntax_version("syntax_version");
source_info.set_location("location");
source_info.set_line_offsets({1, 2, 3});
source_info.set_positions({{1, 1}, {2, 2}});
ASSERT_TRUE(absl::holds_alternative<Ident>(parsed_expr.expr().kind()));
ASSERT_EQ(absl::get<Ident>(parsed_expr.expr().kind()).name(), "name");
ASSERT_EQ(parsed_expr.source_info().syntax_version(), "syntax_version");
ASSERT_EQ(parsed_expr.source_info().location(), "location");
EXPECT_THAT(parsed_expr.source_info().line_offsets(),
testing::UnorderedElementsAre(1, 2, 3));
EXPECT_THAT(
parsed_expr.source_info().positions(),
testing::UnorderedElementsAre(testing::Pair(1, 1), testing::Pair(2, 2)));
}
TEST(AstTest, ListTypeMutableConstruction) {
ListType type;
type.mutable_elem_type() = Type(PrimitiveType::kBool);
EXPECT_EQ(absl::get<PrimitiveType>(type.elem_type().type_kind()),
PrimitiveType::kBool);
}
TEST(AstTest, MapTypeMutableConstruction) {
MapType type;
type.mutable_key_type() = Type(PrimitiveType::kBool);
type.mutable_value_type() = Type(PrimitiveType::kBool);
EXPECT_EQ(absl::get<PrimitiveType>(type.key_type().type_kind()),
PrimitiveType::kBool);
EXPECT_EQ(absl::get<PrimitiveType>(type.value_type().type_kind()),
PrimitiveType::kBool);
}
TEST(AstTest, MapTypeComparatorKeyType) {
MapType type;
type.mutable_key_type() = Type(PrimitiveType::kBool);
EXPECT_FALSE(type == MapType());
}
TEST(AstTest, MapTypeComparatorValueType) {
MapType type;
type.mutable_value_type() = Type(PrimitiveType::kBool);
EXPECT_FALSE(type == MapType());
}
TEST(AstTest, FunctionTypeMutableConstruction) {
FunctionType type;
type.mutable_result_type() = Type(PrimitiveType::kBool);
EXPECT_EQ(absl::get<PrimitiveType>(type.result_type().type_kind()),
PrimitiveType::kBool);
}
TEST(AstTest, FunctionTypeComparatorArgTypes) {
FunctionType type;
type.mutable_arg_types().emplace_back(Type());
EXPECT_FALSE(type == FunctionType());
}
TEST(AstTest, CheckedExpr) {
CheckedExpr checked_expr;
auto& expr = checked_expr.mutable_expr();
expr.set_id(1);
expr.mutable_ident_expr().set_name("name");
auto& source_info = checked_expr.mutable_source_info();
source_info.set_syntax_version("syntax_version");
source_info.set_location("location");
source_info.set_line_offsets({1, 2, 3});
source_info.set_positions({{1, 1}, {2, 2}});
checked_expr.set_expr_version("expr_version");
checked_expr.mutable_type_map().insert(
{1, Type(PrimitiveType(PrimitiveType::kBool))});
ASSERT_TRUE(absl::holds_alternative<Ident>(checked_expr.expr().kind()));
ASSERT_EQ(absl::get<Ident>(checked_expr.expr().kind()).name(), "name");
ASSERT_EQ(checked_expr.source_info().syntax_version(), "syntax_version");
ASSERT_EQ(checked_expr.source_info().location(), "location");
EXPECT_THAT(checked_expr.source_info().line_offsets(),
testing::UnorderedElementsAre(1, 2, 3));
EXPECT_THAT(
checked_expr.source_info().positions(),
testing::UnorderedElementsAre(testing::Pair(1, 1), testing::Pair(2, 2)));
EXPECT_EQ(checked_expr.expr_version(), "expr_version");
}
TEST(AstTest, ListTypeDefaults) { EXPECT_EQ(ListType().elem_type(), Type()); }
TEST(AstTest, MapTypeDefaults) {
EXPECT_EQ(MapType().key_type(), Type());
EXPECT_EQ(MapType().value_type(), Type());
}
TEST(AstTest, FunctionTypeDefaults) {
EXPECT_EQ(FunctionType().result_type(), Type());
}
TEST(AstTest, TypeDefaults) {
EXPECT_EQ(Type().null(), nullptr);
EXPECT_EQ(Type().primitive(), PrimitiveType::kPrimitiveTypeUnspecified);
EXPECT_EQ(Type().wrapper(), PrimitiveType::kPrimitiveTypeUnspecified);
EXPECT_EQ(Type().well_known(), WellKnownType::kWellKnownTypeUnspecified);
EXPECT_EQ(Type().list_type(), ListType());
EXPECT_EQ(Type().map_type(), MapType());
EXPECT_EQ(Type().function(), FunctionType());
EXPECT_EQ(Type().message_type(), MessageType());
EXPECT_EQ(Type().type_param(), ParamType());
EXPECT_EQ(Type().type(), Type());
EXPECT_EQ(Type().error_type(), ErrorType());
EXPECT_EQ(Type().abstract_type(), AbstractType());
}
TEST(AstTest, TypeComparatorTest) {
Type type;
type.set_type_kind(std::make_unique<Type>(PrimitiveType::kBool));
EXPECT_FALSE(type.type() == Type());
}
TEST(AstTest, ExprMutableConstruction) {
Expr expr;
expr.mutable_const_expr().set_bool_value(true);
ASSERT_TRUE(expr.has_const_expr());
EXPECT_TRUE(expr.const_expr().bool_value());
expr.mutable_ident_expr().set_name("expr");
ASSERT_TRUE(expr.has_ident_expr());
EXPECT_FALSE(expr.has_const_expr());
EXPECT_EQ(expr.ident_expr().name(), "expr");
expr.mutable_select_expr().set_field("field");
ASSERT_TRUE(expr.has_select_expr());
EXPECT_FALSE(expr.has_ident_expr());
EXPECT_EQ(expr.select_expr().field(), "field");
expr.mutable_call_expr().set_function("function");
ASSERT_TRUE(expr.has_call_expr());
EXPECT_FALSE(expr.has_select_expr());
EXPECT_EQ(expr.call_expr().function(), "function");
expr.mutable_list_expr();
EXPECT_TRUE(expr.has_list_expr());
EXPECT_FALSE(expr.has_call_expr());
expr.mutable_struct_expr().set_name("name");
ASSERT_TRUE(expr.has_struct_expr());
EXPECT_EQ(expr.struct_expr().name(), "name");
EXPECT_FALSE(expr.has_list_expr());
expr.mutable_comprehension_expr().set_accu_var("accu_var");
ASSERT_TRUE(expr.has_comprehension_expr());
EXPECT_FALSE(expr.has_list_expr());
EXPECT_EQ(expr.comprehension_expr().accu_var(), "accu_var");
}
TEST(AstTest, ReferenceConstantDefaultValue) {
Reference reference;
EXPECT_EQ(reference.value(), Constant());
}
TEST(AstTest, TypeCopyable) {
Type type = Type(PrimitiveType::kBool);
Type type2 = type;
EXPECT_TRUE(type2.has_primitive());
EXPECT_EQ(type2, type);
type = Type(ListType(std::make_unique<Type>(PrimitiveType::kBool)));
type2 = type;
EXPECT_TRUE(type2.has_list_type());
EXPECT_EQ(type2, type);
type = Type(MapType(std::make_unique<Type>(PrimitiveType::kBool),
std::make_unique<Type>(PrimitiveType::kBool)));
type2 = type;
EXPECT_TRUE(type2.has_map_type());
EXPECT_EQ(type2, type);
type = Type(FunctionType(std::make_unique<Type>(PrimitiveType::kBool), {}));
type2 = type;
EXPECT_TRUE(type2.has_function());
EXPECT_EQ(type2, type);
type = Type(AbstractType("optional", {Type(PrimitiveType::kBool)}));
type2 = type;
EXPECT_TRUE(type2.has_abstract_type());
EXPECT_EQ(type2, type);
}
TEST(AstTest, TypeMoveable) {
Type type = Type(PrimitiveType::kBool);
Type type2 = type;
Type type3 = std::move(type);
EXPECT_TRUE(type2.has_primitive());
EXPECT_EQ(type2, type3);
type = Type(ListType(std::make_unique<Type>(PrimitiveType::kBool)));
type2 = type;
type3 = std::move(type);
EXPECT_TRUE(type2.has_list_type());
EXPECT_EQ(type2, type3);
type = Type(MapType(std::make_unique<Type>(PrimitiveType::kBool),
std::make_unique<Type>(PrimitiveType::kBool)));
type2 = type;
type3 = std::move(type);
EXPECT_TRUE(type2.has_map_type());
EXPECT_EQ(type2, type3);
type = Type(FunctionType(std::make_unique<Type>(PrimitiveType::kBool), {}));
type2 = type;
type3 = std::move(type);
EXPECT_TRUE(type2.has_function());
EXPECT_EQ(type2, type3);
type = Type(AbstractType("optional", {Type(PrimitiveType::kBool)}));
type2 = type;
type3 = std::move(type);
EXPECT_TRUE(type2.has_abstract_type());
EXPECT_EQ(type2, type3);
}
TEST(AstTest, NestedTypeKindCopyAssignable) {
ListType list_type(std::make_unique<Type>(PrimitiveType::kBool));
ListType list_type2;
list_type2 = list_type;
EXPECT_EQ(list_type2, list_type);
MapType map_type(std::make_unique<Type>(PrimitiveType::kBool),
std::make_unique<Type>(PrimitiveType::kBool));
MapType map_type2;
map_type2 = map_type;
AbstractType abstract_type(
"abstract", {Type(PrimitiveType::kBool), Type(PrimitiveType::kBool)});
AbstractType abstract_type2;
abstract_type2 = abstract_type;
EXPECT_EQ(abstract_type2, abstract_type);
FunctionType function_type(
std::make_unique<Type>(PrimitiveType::kBool),
{Type(PrimitiveType::kBool), Type(PrimitiveType::kBool)});
FunctionType function_type2;
function_type2 = function_type;
EXPECT_EQ(function_type2, function_type);
}
TEST(AstTest, ExtensionSupported) {
SourceInfo source_info;
source_info.mutable_extensions().push_back(
Extension("constant_folding", nullptr, {}));
EXPECT_EQ(source_info.extensions()[0],
Extension("constant_folding", nullptr, {}));
}
TEST(AstTest, ExtensionEquality) {
Extension extension1("constant_folding", nullptr, {});
EXPECT_EQ(extension1, Extension("constant_folding", nullptr, {}));
EXPECT_NE(extension1,
Extension("constant_folding",
std::make_unique<Extension::Version>(1, 0), {}));
EXPECT_NE(extension1, Extension("constant_folding", nullptr,
{Extension::Component::kRuntime}));
EXPECT_EQ(extension1,
Extension("constant_folding",
std::make_unique<Extension::Version>(0, 0), {}));
}
}
}
} | 5 |
#ifndef THIRD_PARTY_CEL_CPP_COMMON_DECL_H_
#define THIRD_PARTY_CEL_CPP_COMMON_DECL_H_
#include <cstddef>
#include <string>
#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
#include "absl/base/attributes.h"
#include "absl/container/flat_hash_set.h"
#include "absl/hash/hash.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "common/constant.h"
#include "common/type.h"
#include "internal/status_macros.h"
namespace cel {
class VariableDecl;
class OverloadDecl;
class FunctionDecl;
class VariableDecl final {
public:
VariableDecl() = default;
VariableDecl(const VariableDecl&) = default;
VariableDecl(VariableDecl&&) = default;
VariableDecl& operator=(const VariableDecl&) = default;
VariableDecl& operator=(VariableDecl&&) = default;
ABSL_MUST_USE_RESULT const std::string& name() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return name_;
}
void set_name(std::string name) { name_ = std::move(name); }
void set_name(absl::string_view name) {
name_.assign(name.data(), name.size());
}
void set_name(const char* name) { set_name(absl::NullSafeStringView(name)); }
ABSL_MUST_USE_RESULT std::string release_name() {
std::string released;
released.swap(name_);
return released;
}
ABSL_MUST_USE_RESULT const Type& type() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
return type_;
}
ABSL_MUST_USE_RESULT Type& mutable_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
return type_;
}
void set_type(Type type) { mutable_type() = std::move(type); }
ABSL_MUST_USE_RESULT bool has_value() const { return value_.has_value(); }
ABSL_MUST_USE_RESULT const Constant& value() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return has_value() ? *value_ : Constant::default_instance();
}
Constant& mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
if (!has_value()) {
value_.emplace();
}
return *value_;
}
void set_value(absl::optional<Constant> value) { value_ = std::move(value); }
void set_value(Constant value) { mutable_value() = std::move(value); }
ABSL_MUST_USE_RESULT Constant release_value() {
absl::optional<Constant> released;
released.swap(value_);
return std::move(released).value_or(Constant{});
}
private:
std::string name_;
Type type_ = DynType{};
absl::optional<Constant> value_;
};
inline VariableDecl MakeVariableDecl(std::string name, Type type) {
VariableDecl variable_decl;
variable_decl.set_name(std::move(name));
variable_decl.set_type(std::move(type));
return variable_decl;
}
inline VariableDecl MakeConstantVariableDecl(std::string name, Type type,
Constant value) {
VariableDecl variable_decl;
variable_decl.set_name(std::move(name));
variable_decl.set_type(std::move(type));
variable_decl.set_value(std::move(value));
return variable_decl;
}
inline bool operator==(const VariableDecl& lhs, const VariableDecl& rhs) {
return lhs.name() == rhs.name() && lhs.type() == rhs.type() &&
lhs.has_value() == rhs.has_value() && lhs.value() == rhs.value();
}
inline bool operator!=(const VariableDecl& lhs, const VariableDecl& rhs) {
return !operator==(lhs, rhs);
}
class OverloadDecl final {
public:
OverloadDecl() = default;
OverloadDecl(const OverloadDecl&) = default;
OverloadDecl(OverloadDecl&&) = default;
OverloadDecl& operator=(const OverloadDecl&) = default;
OverloadDecl& operator=(OverloadDecl&&) = default;
ABSL_MUST_USE_RESULT const std::string& id() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return id_;
}
void set_id(std::string id) { id_ = std::move(id); }
void set_id(absl::string_view id) { id_.assign(id.data(), id.size()); }
void set_id(const char* id) { set_id(absl::NullSafeStringView(id)); }
ABSL_MUST_USE_RESULT std::string release_id() {
std::string released;
released.swap(id_);
return released;
}
ABSL_MUST_USE_RESULT const std::vector<Type>& args() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return args_;
}
ABSL_MUST_USE_RESULT std::vector<Type>& mutable_args()
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return args_;
}
ABSL_MUST_USE_RESULT std::vector<Type> release_args() {
std::vector<Type> released;
released.swap(mutable_args());
return released;
}
ABSL_MUST_USE_RESULT const Type& result() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return result_;
}
ABSL_MUST_USE_RESULT Type& mutable_result() ABSL_ATTRIBUTE_LIFETIME_BOUND {
return result_;
}
void set_result(Type result) { mutable_result() = std::move(result); }
ABSL_MUST_USE_RESULT bool member() const { return member_; }
void set_member(bool member) { member_ = member; }
absl::flat_hash_set<std::string> GetTypeParams() const;
private:
std::string id_;
std::vector<Type> args_;
Type result_ = DynType{};
bool member_ = false;
};
inline bool operator==(const OverloadDecl& lhs, const OverloadDecl& rhs) {
return lhs.id() == rhs.id() && absl::c_equal(lhs.args(), rhs.args()) &&
lhs.result() == rhs.result() && lhs.member() == rhs.member();
}
inline bool operator!=(const OverloadDecl& lhs, const OverloadDecl& rhs) {
return !operator==(lhs, rhs);
}
template <typename... Args>
OverloadDecl MakeOverloadDecl(std::string id, Type result, Args&&... args) {
OverloadDecl overload_decl;
overload_decl.set_id(std::move(id));
overload_decl.set_result(std::move(result));
overload_decl.set_member(false);
auto& mutable_args = overload_decl.mutable_args();
mutable_args.reserve(sizeof...(Args));
(mutable_args.push_back(std::forward<Args>(args)), ...);
return overload_decl;
}
template <typename... Args>
OverloadDecl MakeMemberOverloadDecl(std::string id, Type result,
Args&&... args) {
OverloadDecl overload_decl;
overload_decl.set_id(std::move(id));
overload_decl.set_result(std::move(result));
overload_decl.set_member(true);
auto& mutable_args = overload_decl.mutable_args();
mutable_args.reserve(sizeof...(Args));
(mutable_args.push_back(std::forward<Args>(args)), ...);
return overload_decl;
}
struct OverloadDeclHash {
using is_transparent = void;
size_t operator()(const OverloadDecl& overload_decl) const {
return (*this)(overload_decl.id());
}
size_t operator()(absl::string_view id) const { return absl::HashOf(id); }
};
struct OverloadDeclEqualTo {
using is_transparent = void;
bool operator()(const OverloadDecl& lhs, const OverloadDecl& rhs) const {
return (*this)(lhs.id(), rhs.id());
}
bool operator()(const OverloadDecl& lhs, absl::string_view rhs) const {
return (*this)(lhs.id(), rhs);
}
bool operator()(absl::string_view lhs, const OverloadDecl& rhs) const {
return (*this)(lhs, rhs.id());
}
bool operator()(absl::string_view lhs, absl::string_view rhs) const {
return lhs == rhs;
}
};
using OverloadDeclHashSet =
absl::flat_hash_set<OverloadDecl, OverloadDeclHash, OverloadDeclEqualTo>;
template <typename... Overloads>
absl::StatusOr<FunctionDecl> MakeFunctionDecl(std::string name,
Overloads&&... overloads);
class FunctionDecl final {
public:
FunctionDecl() = default;
FunctionDecl(const FunctionDecl&) = default;
FunctionDecl(FunctionDecl&&) = default;
FunctionDecl& operator=(const FunctionDecl&) = default;
FunctionDecl& operator=(FunctionDecl&&) = default;
ABSL_MUST_USE_RESULT const std::string& name() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return name_;
}
void set_name(std::string name) { name_ = std::move(name); }
void set_name(absl::string_view name) {
name_.assign(name.data(), name.size());
}
void set_name(const char* name) { set_name(absl::NullSafeStringView(name)); }
ABSL_MUST_USE_RESULT std::string release_name() {
std::string released;
released.swap(name_);
return released;
}
absl::Status AddOverload(const OverloadDecl& overload) {
absl::Status status;
AddOverloadImpl(overload, status);
return status;
}
absl::Status AddOverload(OverloadDecl&& overload) {
absl::Status status;
AddOverloadImpl(std::move(overload), status);
return status;
}
ABSL_MUST_USE_RESULT const OverloadDeclHashSet& overloads() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return overloads_;
}
ABSL_MUST_USE_RESULT OverloadDeclHashSet release_overloads() {
OverloadDeclHashSet released;
released.swap(overloads_);
return released;
}
private:
template <typename... Overloads>
friend absl::StatusOr<FunctionDecl> MakeFunctionDecl(
std::string name, Overloads&&... overloads);
void AddOverloadImpl(const OverloadDecl& overload, absl::Status& status);
void AddOverloadImpl(OverloadDecl&& overload, absl::Status& status);
std::string name_;
OverloadDeclHashSet overloads_;
};
inline bool operator==(const FunctionDecl& lhs, const FunctionDecl& rhs) {
return lhs.name() == rhs.name() &&
absl::c_equal(lhs.overloads(), rhs.overloads());
}
inline bool operator!=(const FunctionDecl& lhs, const FunctionDecl& rhs) {
return !operator==(lhs, rhs);
}
template <typename... Overloads>
absl::StatusOr<FunctionDecl> MakeFunctionDecl(std::string name,
Overloads&&... overloads) {
FunctionDecl function_decl;
function_decl.set_name(std::move(name));
function_decl.overloads_.reserve(sizeof...(Overloads));
absl::Status status;
(function_decl.AddOverloadImpl(std::forward<Overloads>(overloads), status),
...);
CEL_RETURN_IF_ERROR(status);
return function_decl;
}
namespace common_internal {
bool TypeIsAssignable(TypeView to, TypeView from);
}
}
#endif
#include "common/decl.h"
#include <cstddef>
#include <string>
#include <utility>
#include "absl/container/flat_hash_set.h"
#include "absl/log/absl_check.h"
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "common/casting.h"
#include "common/type.h"
#include "common/type_kind.h"
namespace cel {
namespace common_internal {
bool TypeIsAssignable(TypeView to, TypeView from) {
if (to == from) {
return true;
}
const auto to_kind = to.kind();
if (to_kind == TypeKind::kDyn) {
return true;
}
switch (to_kind) {
case TypeKind::kBoolWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(BoolTypeView{}, from);
case TypeKind::kIntWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(IntTypeView{}, from);
case TypeKind::kUintWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(UintTypeView{}, from);
case TypeKind::kDoubleWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(DoubleTypeView{}, from);
case TypeKind::kBytesWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(BytesTypeView{}, from);
case TypeKind::kStringWrapper:
return TypeIsAssignable(NullTypeView{}, from) ||
TypeIsAssignable(StringTypeView{}, from);
default:
break;
}
const auto from_kind = from.kind();
if (to_kind != from_kind || to.name() != from.name()) {
return false;
}
const auto& to_params = to.parameters();
const auto& from_params = from.parameters();
const auto params_size = to_params.size();
if (params_size != from_params.size()) {
return false;
}
for (size_t i = 0; i < params_size; ++i) {
if (!TypeIsAssignable(to_params[i], from_params[i])) {
return false;
}
}
return true;
}
}
namespace {
bool SignaturesOverlap(const OverloadDecl& lhs, const OverloadDecl& rhs) {
if (lhs.member() != rhs.member()) {
return false;
}
const auto& lhs_args = lhs.args();
const auto& rhs_args = rhs.args();
const auto args_size = lhs_args.size();
if (args_size != rhs_args.size()) {
return false;
}
bool args_overlap = true;
for (size_t i = 0; i < args_size; ++i) {
args_overlap =
args_overlap &&
(common_internal::TypeIsAssignable(lhs_args[i], rhs_args[i]) ||
common_internal::TypeIsAssignable(rhs_args[i], lhs_args[i]));
}
return args_overlap;
}
template <typename Overload>
void AddOverloadInternal(OverloadDeclHashSet& overloads, Overload&& overload,
absl::Status& status) {
if (!status.ok()) {
return;
}
if (auto it = overloads.find(overload.id()); it != overloads.end()) {
status = absl::AlreadyExistsError(
absl::StrCat("overload already exists: ", overload.id()));
return;
}
for (const auto& existing : overloads) {
if (SignaturesOverlap(overload, existing)) {
status = absl::InvalidArgumentError(
absl::StrCat("overload signature collision: ", existing.id(),
" collides with ", overload.id()));
return;
}
}
const auto inserted =
overloads.insert(std::forward<Overload>(overload)).second;
ABSL_DCHECK(inserted);
}
void CollectTypeParams(absl::flat_hash_set<std::string>& type_params,
TypeView type) {
const auto kind = type.kind();
switch (kind) {
case TypeKind::kList: {
const auto& list_type = cel::Cast<ListTypeView>(type);
CollectTypeParams(type_params, list_type.element());
} break;
case TypeKind::kMap: {
const auto& map_type = cel::Cast<MapTypeView>(type);
CollectTypeParams(type_params, map_type.key());
CollectTypeParams(type_params, map_type.value());
} break;
case TypeKind::kOpaque: {
const auto& opaque_type = cel::Cast<OpaqueTypeView>(type);
for (const auto& param : opaque_type.parameters()) {
CollectTypeParams(type_params, param);
}
} break;
case TypeKind::kFunction: {
const auto& function_type = cel::Cast<FunctionTypeView>(type);
CollectTypeParams(type_params, function_type.result());
for (const auto& arg : function_type.args()) {
CollectTypeParams(type_params, arg);
}
} break;
case TypeKind::kTypeParam:
type_params.emplace(cel::Cast<TypeParamTypeView>(type).name());
break;
default:
break;
}
}
}
absl::flat_hash_set<std::string> OverloadDecl::GetTypeParams() const {
absl::flat_hash_set<std::string> type_params;
CollectTypeParams(type_params, result());
for (const auto& arg : args()) {
CollectTypeParams(type_params, arg);
}
return type_params;
}
void FunctionDecl::AddOverloadImpl(const OverloadDecl& overload,
absl::Status& status) {
AddOverloadInternal(overloads_, overload, status);
}
void FunctionDecl::AddOverloadImpl(OverloadDecl&& overload,
absl::Status& status) {
AddOverloadInternal(overloads_, std::move(overload), status);
}
} | #include "common/decl.h"
#include "absl/status/status.h"
#include "common/constant.h"
#include "common/memory.h"
#include "common/type.h"
#include "internal/testing.h"
namespace cel {
namespace {
using testing::ElementsAre;
using testing::IsEmpty;
using testing::UnorderedElementsAre;
using cel::internal::StatusIs;
TEST(VariableDecl, Name) {
VariableDecl variable_decl;
EXPECT_THAT(variable_decl.name(), IsEmpty());
variable_decl.set_name("foo");
EXPECT_EQ(variable_decl.name(), "foo");
EXPECT_EQ(variable_decl.release_name(), "foo");
EXPECT_THAT(variable_decl.name(), IsEmpty());
}
TEST(VariableDecl, Type) {
VariableDecl variable_decl;
EXPECT_EQ(variable_decl.type(), DynType{});
variable_decl.set_type(StringType{});
EXPECT_EQ(variable_decl.type(), StringType{});
}
TEST(VariableDecl, Value) {
VariableDecl variable_decl;
EXPECT_FALSE(variable_decl.has_value());
EXPECT_EQ(variable_decl.value(), Constant{});
Constant value;
value.set_bool_value(true);
variable_decl.set_value(value);
EXPECT_TRUE(variable_decl.has_value());
EXPECT_EQ(variable_decl.value(), value);
EXPECT_EQ(variable_decl.release_value(), value);
EXPECT_EQ(variable_decl.value(), Constant{});
}
Constant MakeBoolConstant(bool value) {
Constant constant;
constant.set_bool_value(value);
return constant;
}
TEST(VariableDecl, Equality) {
VariableDecl variable_decl;
EXPECT_EQ(variable_decl, VariableDecl{});
variable_decl.mutable_value().set_bool_value(true);
EXPECT_NE(variable_decl, VariableDecl{});
EXPECT_EQ(MakeVariableDecl("foo", StringType{}),
MakeVariableDecl("foo", StringType{}));
EXPECT_EQ(MakeVariableDecl("foo", StringType{}),
MakeVariableDecl("foo", StringType{}));
EXPECT_EQ(
MakeConstantVariableDecl("foo", StringType{}, MakeBoolConstant(true)),
MakeConstantVariableDecl("foo", StringType{}, MakeBoolConstant(true)));
EXPECT_EQ(
MakeConstantVariableDecl("foo", StringType{}, MakeBoolConstant(true)),
MakeConstantVariableDecl("foo", StringType{}, MakeBoolConstant(true)));
}
TEST(OverloadDecl, Id) {
OverloadDecl overload_decl;
EXPECT_THAT(overload_decl.id(), IsEmpty());
overload_decl.set_id("foo");
EXPECT_EQ(overload_decl.id(), "foo");
EXPECT_EQ(overload_decl.release_id(), "foo");
EXPECT_THAT(overload_decl.id(), IsEmpty());
}
TEST(OverloadDecl, Result) {
OverloadDecl overload_decl;
EXPECT_EQ(overload_decl.result(), DynType{});
overload_decl.set_result(StringType{});
EXPECT_EQ(overload_decl.result(), StringType{});
}
TEST(OverloadDecl, Args) {
OverloadDecl overload_decl;
EXPECT_THAT(overload_decl.args(), IsEmpty());
overload_decl.mutable_args().push_back(StringType{});
EXPECT_THAT(overload_decl.args(), ElementsAre(StringType{}));
EXPECT_THAT(overload_decl.release_args(), ElementsAre(StringType{}));
EXPECT_THAT(overload_decl.args(), IsEmpty());
}
TEST(OverloadDecl, Member) {
OverloadDecl overload_decl;
EXPECT_FALSE(overload_decl.member());
overload_decl.set_member(true);
EXPECT_TRUE(overload_decl.member());
}
TEST(OverloadDecl, Equality) {
OverloadDecl overload_decl;
EXPECT_EQ(overload_decl, OverloadDecl{});
overload_decl.set_member(true);
EXPECT_NE(overload_decl, OverloadDecl{});
}
TEST(OverloadDecl, GetTypeParams) {
auto memory_manager = MemoryManagerRef::ReferenceCounting();
auto overload_decl = MakeOverloadDecl(
"foo", ListType(memory_manager, TypeParamType(memory_manager, "A")),
MapType(memory_manager, TypeParamType(memory_manager, "B"),
TypeParamType(memory_manager, "C")),
OpaqueType(memory_manager, "bar",
{FunctionType(memory_manager,
TypeParamType(memory_manager, "D"), {})}));
EXPECT_THAT(overload_decl.GetTypeParams(),
UnorderedElementsAre("A", "B", "C", "D"));
}
TEST(FunctionDecl, Name) {
FunctionDecl function_decl;
EXPECT_THAT(function_decl.name(), IsEmpty());
function_decl.set_name("foo");
EXPECT_EQ(function_decl.name(), "foo");
EXPECT_EQ(function_decl.release_name(), "foo");
EXPECT_THAT(function_decl.name(), IsEmpty());
}
TEST(FunctionDecl, Overloads) {
ASSERT_OK_AND_ASSIGN(
auto function_decl,
MakeFunctionDecl(
"hello", MakeOverloadDecl("foo", StringType{}, StringType{}),
MakeMemberOverloadDecl("bar", StringType{}, StringType{})));
EXPECT_THAT(function_decl.AddOverload(
MakeOverloadDecl("baz", DynType{}, StringType{})),
StatusIs(absl::StatusCode::kInvalidArgument));
}
using common_internal::TypeIsAssignable;
TEST(TypeIsAssignable, BoolWrapper) {
EXPECT_TRUE(TypeIsAssignable(BoolWrapperTypeView{}, BoolWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(BoolWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(BoolWrapperTypeView{}, BoolTypeView{}));
EXPECT_FALSE(TypeIsAssignable(BoolWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, IntWrapper) {
EXPECT_TRUE(TypeIsAssignable(IntWrapperTypeView{}, IntWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(IntWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(IntWrapperTypeView{}, IntTypeView{}));
EXPECT_FALSE(TypeIsAssignable(IntWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, UintWrapper) {
EXPECT_TRUE(TypeIsAssignable(UintWrapperTypeView{}, UintWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(UintWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(UintWrapperTypeView{}, UintTypeView{}));
EXPECT_FALSE(TypeIsAssignable(UintWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, DoubleWrapper) {
EXPECT_TRUE(
TypeIsAssignable(DoubleWrapperTypeView{}, DoubleWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(DoubleWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(DoubleWrapperTypeView{}, DoubleTypeView{}));
EXPECT_FALSE(TypeIsAssignable(DoubleWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, BytesWrapper) {
EXPECT_TRUE(TypeIsAssignable(BytesWrapperTypeView{}, BytesWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(BytesWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(BytesWrapperTypeView{}, BytesTypeView{}));
EXPECT_FALSE(TypeIsAssignable(BytesWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, StringWrapper) {
EXPECT_TRUE(
TypeIsAssignable(StringWrapperTypeView{}, StringWrapperTypeView{}));
EXPECT_TRUE(TypeIsAssignable(StringWrapperTypeView{}, NullTypeView{}));
EXPECT_TRUE(TypeIsAssignable(StringWrapperTypeView{}, StringTypeView{}));
EXPECT_FALSE(TypeIsAssignable(StringWrapperTypeView{}, DurationTypeView{}));
}
TEST(TypeIsAssignable, Complex) {
auto memory_manager = MemoryManagerRef::ReferenceCounting();
EXPECT_TRUE(TypeIsAssignable(OptionalType(memory_manager, DynTypeView{}),
OptionalType(memory_manager, StringTypeView{})));
EXPECT_FALSE(
TypeIsAssignable(OptionalType(memory_manager, BoolTypeView{}),
OptionalType(memory_manager, StringTypeView{})));
}
}
} | 6 |
#ifndef THIRD_PARTY_CEL_CPP_COMMON_TYPE_FACTORY_H_
#define THIRD_PARTY_CEL_CPP_COMMON_TYPE_FACTORY_H_
#include "absl/strings/string_view.h"
#include "common/memory.h"
#include "common/sized_input_view.h"
#include "common/type.h"
namespace cel {
namespace common_internal {
class PiecewiseValueManager;
}
class TypeFactory {
public:
virtual ~TypeFactory() = default;
virtual MemoryManagerRef GetMemoryManager() const = 0;
ListType CreateListType(TypeView element);
MapType CreateMapType(TypeView key, TypeView value);
StructType CreateStructType(absl::string_view name);
OpaqueType CreateOpaqueType(absl::string_view name,
const SizedInputView<TypeView>& parameters);
OptionalType CreateOptionalType(TypeView parameter);
ListTypeView GetDynListType();
MapTypeView GetDynDynMapType();
MapTypeView GetStringDynMapType();
OptionalTypeView GetDynOptionalType();
NullType GetNullType() { return NullType{}; }
ErrorType GetErrorType() { return ErrorType{}; }
DynType GetDynType() { return DynType{}; }
AnyType GetAnyType() { return AnyType{}; }
BoolType GetBoolType() { return BoolType{}; }
IntType GetIntType() { return IntType{}; }
UintType GetUintType() { return UintType{}; }
DoubleType GetDoubleType() { return DoubleType{}; }
StringType GetStringType() { return StringType{}; }
BytesType GetBytesType() { return BytesType{}; }
DurationType GetDurationType() { return DurationType{}; }
TimestampType GetTimestampType() { return TimestampType{}; }
TypeType GetTypeType() { return TypeType{}; }
UnknownType GetUnknownType() { return UnknownType{}; }
BoolWrapperType GetBoolWrapperType() { return BoolWrapperType{}; }
BytesWrapperType GetBytesWrapperType() { return BytesWrapperType{}; }
DoubleWrapperType GetDoubleWrapperType() { return DoubleWrapperType{}; }
IntWrapperType GetIntWrapperType() { return IntWrapperType{}; }
StringWrapperType GetStringWrapperType() { return StringWrapperType{}; }
UintWrapperType GetUintWrapperType() { return UintWrapperType{}; }
Type GetJsonValueType() { return DynType{}; }
ListType GetJsonListType() { return ListType(GetDynListType()); }
MapType GetJsonMapType() { return MapType(GetStringDynMapType()); }
protected:
friend class common_internal::PiecewiseValueManager;
virtual ListType CreateListTypeImpl(TypeView element) = 0;
virtual MapType CreateMapTypeImpl(TypeView key, TypeView value) = 0;
virtual StructType CreateStructTypeImpl(absl::string_view name) = 0;
virtual OpaqueType CreateOpaqueTypeImpl(
absl::string_view name, const SizedInputView<TypeView>& parameters) = 0;
};
}
#endif
#include "common/type_factory.h"
#include "absl/base/attributes.h"
#include "absl/log/absl_check.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "common/casting.h"
#include "common/sized_input_view.h"
#include "common/type.h"
#include "common/type_kind.h"
#include "common/types/type_cache.h"
#include "internal/names.h"
namespace cel {
namespace {
using common_internal::ListTypeCacheMap;
using common_internal::MapTypeCacheMap;
using common_internal::OpaqueTypeCacheMap;
using common_internal::ProcessLocalTypeCache;
using common_internal::StructTypeCacheMap;
bool IsValidMapKeyType(TypeView type) {
switch (type.kind()) {
case TypeKind::kDyn:
ABSL_FALLTHROUGH_INTENDED;
case TypeKind::kError:
ABSL_FALLTHROUGH_INTENDED;
case TypeKind::kBool:
ABSL_FALLTHROUGH_INTENDED;
case TypeKind::kInt:
ABSL_FALLTHROUGH_INTENDED;
case TypeKind::kUint:
ABSL_FALLTHROUGH_INTENDED;
case TypeKind::kString:
return true;
default:
return false;
}
}
}
ListType TypeFactory::CreateListType(TypeView element) {
if (auto list_type = ProcessLocalTypeCache::Get()->FindListType(element);
list_type.has_value()) {
return ListType(*list_type);
}
return CreateListTypeImpl(element);
}
MapType TypeFactory::CreateMapType(TypeView key, TypeView value) {
ABSL_DCHECK(IsValidMapKeyType(key)) << key;
if (auto map_type = ProcessLocalTypeCache::Get()->FindMapType(key, value);
map_type.has_value()) {
return MapType(*map_type);
}
return CreateMapTypeImpl(key, value);
}
StructType TypeFactory::CreateStructType(absl::string_view name) {
ABSL_DCHECK(internal::IsValidRelativeName(name)) << name;
return CreateStructTypeImpl(name);
}
OpaqueType TypeFactory::CreateOpaqueType(
absl::string_view name, const SizedInputView<TypeView>& parameters) {
ABSL_DCHECK(internal::IsValidRelativeName(name)) << name;
if (auto opaque_type =
ProcessLocalTypeCache::Get()->FindOpaqueType(name, parameters);
opaque_type.has_value()) {
return OpaqueType(*opaque_type);
}
return CreateOpaqueTypeImpl(name, parameters);
}
OptionalType TypeFactory::CreateOptionalType(TypeView parameter) {
return Cast<OptionalType>(CreateOpaqueType(OptionalType::kName, {parameter}));
}
ListTypeView TypeFactory::GetDynListType() {
return ProcessLocalTypeCache::Get()->GetDynListType();
}
MapTypeView TypeFactory::GetDynDynMapType() {
return ProcessLocalTypeCache::Get()->GetDynDynMapType();
}
MapTypeView TypeFactory::GetStringDynMapType() {
return ProcessLocalTypeCache::Get()->GetStringDynMapType();
}
OptionalTypeView TypeFactory::GetDynOptionalType() {
return ProcessLocalTypeCache::Get()->GetDynOptionalType();
}
} | #include "common/type_factory.h"
#include <ostream>
#include <sstream>
#include <string>
#include <tuple>
#include "absl/types/optional.h"
#include "common/memory.h"
#include "common/memory_testing.h"
#include "common/type.h"
#include "common/type_introspector.h"
#include "common/type_manager.h"
#include "common/types/type_cache.h"
#include "internal/testing.h"
namespace cel {
namespace {
using common_internal::ProcessLocalTypeCache;
using testing::_;
using testing::Eq;
using testing::Ne;
using testing::TestParamInfo;
using testing::TestWithParam;
enum class ThreadSafety {
kCompatible,
kSafe,
};
std::ostream& operator<<(std::ostream& out, ThreadSafety thread_safety) {
switch (thread_safety) {
case ThreadSafety::kCompatible:
return out << "THREAD_SAFE";
case ThreadSafety::kSafe:
return out << "THREAD_COMPATIBLE";
}
}
class TypeFactoryTest
: public common_internal::ThreadCompatibleMemoryTest<ThreadSafety> {
public:
void SetUp() override {
ThreadCompatibleMemoryTest::SetUp();
switch (thread_safety()) {
case ThreadSafety::kCompatible:
type_manager_ = NewThreadCompatibleTypeManager(
memory_manager(),
NewThreadCompatibleTypeIntrospector(memory_manager()));
break;
case ThreadSafety::kSafe:
type_manager_ = NewThreadSafeTypeManager(
memory_manager(), NewThreadSafeTypeIntrospector(memory_manager()));
break;
}
}
void TearDown() override { Finish(); }
void Finish() {
type_manager_.reset();
ThreadCompatibleMemoryTest::Finish();
}
TypeFactory& type_factory() const { return **type_manager_; }
ThreadSafety thread_safety() const { return std::get<1>(GetParam()); }
static std::string ToString(
TestParamInfo<std::tuple<MemoryManagement, ThreadSafety>> param) {
std::ostringstream out;
out << std::get<0>(param.param) << "_" << std::get<1>(param.param);
return out.str();
}
private:
absl::optional<Shared<TypeManager>> type_manager_;
};
TEST_P(TypeFactoryTest, ListType) {
auto list_type1 = type_factory().CreateListType(StringType());
EXPECT_THAT(type_factory().CreateListType(StringType()), Eq(list_type1));
EXPECT_THAT(type_factory().CreateListType(BytesType()), Ne(list_type1));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto list_type2 = type_factory().CreateListType(struct_type1);
EXPECT_THAT(type_factory().CreateListType(struct_type1), Eq(list_type2));
EXPECT_THAT(type_factory().CreateListType(struct_type2), Ne(list_type2));
EXPECT_EQ(type_factory().GetDynListType(),
ProcessLocalTypeCache::Get()->GetDynListType());
}
TEST_P(TypeFactoryTest, MapType) {
auto map_type1 = type_factory().CreateMapType(StringType(), BytesType());
EXPECT_THAT(type_factory().CreateMapType(StringType(), BytesType()),
Eq(map_type1));
EXPECT_THAT(type_factory().CreateMapType(StringType(), StringType()),
Ne(map_type1));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto map_type2 = type_factory().CreateMapType(StringType(), struct_type1);
EXPECT_THAT(type_factory().CreateMapType(StringType(), struct_type1),
Eq(map_type2));
EXPECT_THAT(type_factory().CreateMapType(StringType(), struct_type2),
Ne(map_type2));
EXPECT_EQ(type_factory().GetDynDynMapType(),
ProcessLocalTypeCache::Get()->GetDynDynMapType());
EXPECT_EQ(type_factory().GetStringDynMapType(),
ProcessLocalTypeCache::Get()->GetStringDynMapType());
}
TEST_P(TypeFactoryTest, MapTypeInvalidKeyType) {
EXPECT_DEBUG_DEATH(type_factory().CreateMapType(DoubleType(), BytesType()),
_);
}
TEST_P(TypeFactoryTest, StructType) {
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
EXPECT_THAT(type_factory().CreateStructType("test.Struct1"),
Eq(struct_type1));
EXPECT_THAT(type_factory().CreateStructType("test.Struct2"),
Ne(struct_type1));
}
TEST_P(TypeFactoryTest, StructTypeBadName) {
EXPECT_DEBUG_DEATH(type_factory().CreateStructType("test.~"), _);
}
TEST_P(TypeFactoryTest, OpaqueType) {
auto opaque_type1 =
type_factory().CreateOpaqueType("test.Struct1", {BytesType()});
EXPECT_THAT(type_factory().CreateOpaqueType("test.Struct1", {BytesType()}),
Eq(opaque_type1));
EXPECT_THAT(type_factory().CreateOpaqueType("test.Struct2", {}),
Ne(opaque_type1));
}
TEST_P(TypeFactoryTest, OpaqueTypeBadName) {
EXPECT_DEBUG_DEATH(type_factory().CreateOpaqueType("test.~", {}), _);
}
TEST_P(TypeFactoryTest, OptionalType) {
auto optional_type1 = type_factory().CreateOptionalType(StringType());
EXPECT_THAT(type_factory().CreateOptionalType(StringType()),
Eq(optional_type1));
EXPECT_THAT(type_factory().CreateOptionalType(BytesType()),
Ne(optional_type1));
auto struct_type1 = type_factory().CreateStructType("test.Struct1");
auto struct_type2 = type_factory().CreateStructType("test.Struct2");
auto optional_type2 = type_factory().CreateOptionalType(struct_type1);
EXPECT_THAT(type_factory().CreateOptionalType(struct_type1),
Eq(optional_type2));
EXPECT_THAT(type_factory().CreateOptionalType(struct_type2),
Ne(optional_type2));
EXPECT_EQ(type_factory().GetDynOptionalType(),
ProcessLocalTypeCache::Get()->GetDynOptionalType());
}
INSTANTIATE_TEST_SUITE_P(
TypeFactoryTest, TypeFactoryTest,
::testing::Combine(::testing::Values(MemoryManagement::kPooling,
MemoryManagement::kReferenceCounting),
::testing::Values(ThreadSafety::kCompatible,
ThreadSafety::kSafe)),
TypeFactoryTest::ToString);
}
} | 7 |
#ifndef THIRD_PARTY_CEL_CPP_EVAL_PUBLIC_AST_TRAVERSE_H_
#define THIRD_PARTY_CEL_CPP_EVAL_PUBLIC_AST_TRAVERSE_H_
#include "google/api/expr/v1alpha1/syntax.pb.h"
#include "eval/public/ast_visitor.h"
namespace google::api::expr::runtime {
struct TraversalOptions {
bool use_comprehension_callbacks;
TraversalOptions() : use_comprehension_callbacks(false) {}
};
void AstTraverse(const google::api::expr::v1alpha1::Expr* expr,
const google::api::expr::v1alpha1::SourceInfo* source_info,
AstVisitor* visitor,
TraversalOptions options = TraversalOptions());
}
#endif
#include "eval/public/ast_traverse.h"
#include <stack>
#include "google/api/expr/v1alpha1/syntax.pb.h"
#include "absl/log/absl_log.h"
#include "absl/types/variant.h"
#include "eval/public/ast_visitor.h"
#include "eval/public/source_position.h"
namespace google::api::expr::runtime {
using google::api::expr::v1alpha1::Expr;
using google::api::expr::v1alpha1::SourceInfo;
using Ident = google::api::expr::v1alpha1::Expr::Ident;
using Select = google::api::expr::v1alpha1::Expr::Select;
using Call = google::api::expr::v1alpha1::Expr::Call;
using CreateList = google::api::expr::v1alpha1::Expr::CreateList;
using CreateStruct = google::api::expr::v1alpha1::Expr::CreateStruct;
using Comprehension = google::api::expr::v1alpha1::Expr::Comprehension;
namespace {
struct ArgRecord {
const Expr* expr;
const SourceInfo* source_info;
const Expr* calling_expr;
int call_arg;
};
struct ComprehensionRecord {
const Expr* expr;
const SourceInfo* source_info;
const Comprehension* comprehension;
const Expr* comprehension_expr;
ComprehensionArg comprehension_arg;
bool use_comprehension_callbacks;
};
struct ExprRecord {
const Expr* expr;
const SourceInfo* source_info;
};
using StackRecordKind =
absl::variant<ExprRecord, ArgRecord, ComprehensionRecord>;
struct StackRecord {
public:
ABSL_ATTRIBUTE_UNUSED static constexpr int kNotCallArg = -1;
static constexpr int kTarget = -2;
StackRecord(const Expr* e, const SourceInfo* info) {
ExprRecord record;
record.expr = e;
record.source_info = info;
record_variant = record;
}
StackRecord(const Expr* e, const SourceInfo* info,
const Comprehension* comprehension,
const Expr* comprehension_expr,
ComprehensionArg comprehension_arg,
bool use_comprehension_callbacks) {
if (use_comprehension_callbacks) {
ComprehensionRecord record;
record.expr = e;
record.source_info = info;
record.comprehension = comprehension;
record.comprehension_expr = comprehension_expr;
record.comprehension_arg = comprehension_arg;
record.use_comprehension_callbacks = use_comprehension_callbacks;
record_variant = record;
return;
}
ArgRecord record;
record.expr = e;
record.source_info = info;
record.calling_expr = comprehension_expr;
record.call_arg = comprehension_arg;
record_variant = record;
}
StackRecord(const Expr* e, const SourceInfo* info, const Expr* call,
int argnum) {
ArgRecord record;
record.expr = e;
record.source_info = info;
record.calling_expr = call;
record.call_arg = argnum;
record_variant = record;
}
StackRecordKind record_variant;
bool visited = false;
};
struct PreVisitor {
void operator()(const ExprRecord& record) {
const Expr* expr = record.expr;
const SourcePosition position(expr->id(), record.source_info);
visitor->PreVisitExpr(expr, &position);
switch (expr->expr_kind_case()) {
case Expr::kConstExpr:
visitor->PreVisitConst(&expr->const_expr(), expr, &position);
break;
case Expr::kIdentExpr:
visitor->PreVisitIdent(&expr->ident_expr(), expr, &position);
break;
case Expr::kSelectExpr:
visitor->PreVisitSelect(&expr->select_expr(), expr, &position);
break;
case Expr::kCallExpr:
visitor->PreVisitCall(&expr->call_expr(), expr, &position);
break;
case Expr::kListExpr:
visitor->PreVisitCreateList(&expr->list_expr(), expr, &position);
break;
case Expr::kStructExpr:
visitor->PreVisitCreateStruct(&expr->struct_expr(), expr, &position);
break;
case Expr::kComprehensionExpr:
visitor->PreVisitComprehension(&expr->comprehension_expr(), expr,
&position);
break;
default:
break;
}
}
void operator()(const ArgRecord&) {}
void operator()(const ComprehensionRecord& record) {
const Expr* expr = record.expr;
const SourcePosition position(expr->id(), record.source_info);
visitor->PreVisitComprehensionSubexpression(
expr, record.comprehension, record.comprehension_arg, &position);
}
AstVisitor* visitor;
};
void PreVisit(const StackRecord& record, AstVisitor* visitor) {
absl::visit(PreVisitor{visitor}, record.record_variant);
}
struct PostVisitor {
void operator()(const ExprRecord& record) {
const Expr* expr = record.expr;
const SourcePosition position(expr->id(), record.source_info);
switch (expr->expr_kind_case()) {
case Expr::kConstExpr:
visitor->PostVisitConst(&expr->const_expr(), expr, &position);
break;
case Expr::kIdentExpr:
visitor->PostVisitIdent(&expr->ident_expr(), expr, &position);
break;
case Expr::kSelectExpr:
visitor->PostVisitSelect(&expr->select_expr(), expr, &position);
break;
case Expr::kCallExpr:
visitor->PostVisitCall(&expr->call_expr(), expr, &position);
break;
case Expr::kListExpr:
visitor->PostVisitCreateList(&expr->list_expr(), expr, &position);
break;
case Expr::kStructExpr:
visitor->PostVisitCreateStruct(&expr->struct_expr(), expr, &position);
break;
case Expr::kComprehensionExpr:
visitor->PostVisitComprehension(&expr->comprehension_expr(), expr,
&position);
break;
default:
ABSL_LOG(ERROR) << "Unsupported Expr kind: " << expr->expr_kind_case();
}
visitor->PostVisitExpr(expr, &position);
}
void operator()(const ArgRecord& record) {
const Expr* expr = record.expr;
const SourcePosition position(expr->id(), record.source_info);
if (record.call_arg == StackRecord::kTarget) {
visitor->PostVisitTarget(record.calling_expr, &position);
} else {
visitor->PostVisitArg(record.call_arg, record.calling_expr, &position);
}
}
void operator()(const ComprehensionRecord& record) {
const Expr* expr = record.expr;
const SourcePosition position(expr->id(), record.source_info);
visitor->PostVisitComprehensionSubexpression(
expr, record.comprehension, record.comprehension_arg, &position);
}
AstVisitor* visitor;
};
void PostVisit(const StackRecord& record, AstVisitor* visitor) {
absl::visit(PostVisitor{visitor}, record.record_variant);
}
void PushSelectDeps(const Select* select_expr, const SourceInfo* source_info,
std::stack<StackRecord>* stack) {
if (select_expr->has_operand()) {
stack->push(StackRecord(&select_expr->operand(), source_info));
}
}
void PushCallDeps(const Call* call_expr, const Expr* expr,
const SourceInfo* source_info,
std::stack<StackRecord>* stack) {
const int arg_size = call_expr->args_size();
for (int i = arg_size - 1; i >= 0; --i) {
stack->push(StackRecord(&call_expr->args(i), source_info, expr, i));
}
if (call_expr->has_target()) {
stack->push(StackRecord(&call_expr->target(), source_info, expr,
StackRecord::kTarget));
}
}
void PushListDeps(const CreateList* list_expr, const SourceInfo* source_info,
std::stack<StackRecord>* stack) {
const auto& elements = list_expr->elements();
for (auto it = elements.rbegin(); it != elements.rend(); ++it) {
const auto& element = *it;
stack->push(StackRecord(&element, source_info));
}
}
void PushStructDeps(const CreateStruct* struct_expr,
const SourceInfo* source_info,
std::stack<StackRecord>* stack) {
const auto& entries = struct_expr->entries();
for (auto it = entries.rbegin(); it != entries.rend(); ++it) {
const auto& entry = *it;
if (entry.has_value()) {
stack->push(StackRecord(&entry.value(), source_info));
}
if (entry.has_map_key()) {
stack->push(StackRecord(&entry.map_key(), source_info));
}
}
}
void PushComprehensionDeps(const Comprehension* c, const Expr* expr,
const SourceInfo* source_info,
std::stack<StackRecord>* stack,
bool use_comprehension_callbacks) {
StackRecord iter_range(&c->iter_range(), source_info, c, expr, ITER_RANGE,
use_comprehension_callbacks);
StackRecord accu_init(&c->accu_init(), source_info, c, expr, ACCU_INIT,
use_comprehension_callbacks);
StackRecord loop_condition(&c->loop_condition(), source_info, c, expr,
LOOP_CONDITION, use_comprehension_callbacks);
StackRecord loop_step(&c->loop_step(), source_info, c, expr, LOOP_STEP,
use_comprehension_callbacks);
StackRecord result(&c->result(), source_info, c, expr, RESULT,
use_comprehension_callbacks);
stack->push(result);
stack->push(loop_step);
stack->push(loop_condition);
stack->push(accu_init);
stack->push(iter_range);
}
struct PushDepsVisitor {
void operator()(const ExprRecord& record) {
const Expr* expr = record.expr;
switch (expr->expr_kind_case()) {
case Expr::kSelectExpr:
PushSelectDeps(&expr->select_expr(), record.source_info, &stack);
break;
case Expr::kCallExpr:
PushCallDeps(&expr->call_expr(), expr, record.source_info, &stack);
break;
case Expr::kListExpr:
PushListDeps(&expr->list_expr(), record.source_info, &stack);
break;
case Expr::kStructExpr:
PushStructDeps(&expr->struct_expr(), record.source_info, &stack);
break;
case Expr::kComprehensionExpr:
PushComprehensionDeps(&expr->comprehension_expr(), expr,
record.source_info, &stack,
options.use_comprehension_callbacks);
break;
default:
break;
}
}
void operator()(const ArgRecord& record) {
stack.push(StackRecord(record.expr, record.source_info));
}
void operator()(const ComprehensionRecord& record) {
stack.push(StackRecord(record.expr, record.source_info));
}
std::stack<StackRecord>& stack;
const TraversalOptions& options;
};
void PushDependencies(const StackRecord& record, std::stack<StackRecord>& stack,
const TraversalOptions& options) {
absl::visit(PushDepsVisitor{stack, options}, record.record_variant);
}
}
void AstTraverse(const Expr* expr, const SourceInfo* source_info,
AstVisitor* visitor, TraversalOptions options) {
std::stack<StackRecord> stack;
stack.push(StackRecord(expr, source_info));
while (!stack.empty()) {
StackRecord& record = stack.top();
if (!record.visited) {
PreVisit(record, visitor);
PushDependencies(record, stack, options);
record.visited = true;
} else {
PostVisit(record, visitor);
stack.pop();
}
}
}
} | #include "eval/public/ast_traverse.h"
#include "eval/public/ast_visitor.h"
#include "internal/testing.h"
namespace google::api::expr::runtime {
namespace {
using google::api::expr::v1alpha1::Constant;
using google::api::expr::v1alpha1::Expr;
using google::api::expr::v1alpha1::SourceInfo;
using testing::_;
using Ident = google::api::expr::v1alpha1::Expr::Ident;
using Select = google::api::expr::v1alpha1::Expr::Select;
using Call = google::api::expr::v1alpha1::Expr::Call;
using CreateList = google::api::expr::v1alpha1::Expr::CreateList;
using CreateStruct = google::api::expr::v1alpha1::Expr::CreateStruct;
using Comprehension = google::api::expr::v1alpha1::Expr::Comprehension;
class MockAstVisitor : public AstVisitor {
public:
MOCK_METHOD(void, PreVisitExpr,
(const Expr* expr, const SourcePosition* position), (override));
MOCK_METHOD(void, PostVisitExpr,
(const Expr* expr, const SourcePosition* position), (override));
MOCK_METHOD(void, PreVisitConst,
(const Constant* const_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitConst,
(const Constant* const_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitIdent,
(const Ident* ident_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitIdent,
(const Ident* ident_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitSelect,
(const Select* select_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitSelect,
(const Select* select_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitCall,
(const Call* call_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitCall,
(const Call* call_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitComprehension,
(const Comprehension* comprehension_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitComprehension,
(const Comprehension* comprehension_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitComprehensionSubexpression,
(const Expr* expr, const Comprehension* comprehension_expr,
ComprehensionArg comprehension_arg,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitComprehensionSubexpression,
(const Expr* expr, const Comprehension* comprehension_expr,
ComprehensionArg comprehension_arg,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitTarget,
(const Expr* expr, const SourcePosition* position), (override));
MOCK_METHOD(void, PostVisitArg,
(int arg_num, const Expr* expr, const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitCreateList,
(const CreateList* list_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitCreateList,
(const CreateList* list_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PreVisitCreateStruct,
(const CreateStruct* struct_expr, const Expr* expr,
const SourcePosition* position),
(override));
MOCK_METHOD(void, PostVisitCreateStruct,
(const CreateStruct* struct_expr, const Expr* expr,
const SourcePosition* position),
(override));
};
TEST(AstCrawlerTest, CheckCrawlConstant) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto const_expr = expr.mutable_const_expr();
EXPECT_CALL(handler, PreVisitConst(const_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(const_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlIdent) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto ident_expr = expr.mutable_ident_expr();
EXPECT_CALL(handler, PreVisitIdent(ident_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(ident_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlSelectNotCrashingPostVisitAbsentOperand) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto select_expr = expr.mutable_select_expr();
EXPECT_CALL(handler, PostVisitSelect(select_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlSelect) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto select_expr = expr.mutable_select_expr();
auto operand = select_expr->mutable_operand();
auto ident_expr = operand->mutable_ident_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PostVisitIdent(ident_expr, operand, _)).Times(1);
EXPECT_CALL(handler, PostVisitSelect(select_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlCallNoReceiver) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto* call_expr = expr.mutable_call_expr();
Expr* arg0 = call_expr->add_args();
auto* const_expr = arg0->mutable_const_expr();
Expr* arg1 = call_expr->add_args();
auto* ident_expr = arg1->mutable_ident_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitCall(call_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitTarget(_, _)).Times(0);
EXPECT_CALL(handler, PostVisitConst(const_expr, arg0, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(arg0, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(0, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(ident_expr, arg1, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(arg1, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(1, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitCall(call_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(&expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlCallReceiver) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto* call_expr = expr.mutable_call_expr();
Expr* target = call_expr->mutable_target();
auto* target_ident = target->mutable_ident_expr();
Expr* arg0 = call_expr->add_args();
auto* const_expr = arg0->mutable_const_expr();
Expr* arg1 = call_expr->add_args();
auto* ident_expr = arg1->mutable_ident_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitCall(call_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(target_ident, target, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(target, _)).Times(1);
EXPECT_CALL(handler, PostVisitTarget(&expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(const_expr, arg0, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(arg0, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(0, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(ident_expr, arg1, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(arg1, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(1, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitCall(call_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitExpr(&expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCrawlComprehension) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto c = expr.mutable_comprehension_expr();
auto iter_range = c->mutable_iter_range();
auto iter_range_expr = iter_range->mutable_const_expr();
auto accu_init = c->mutable_accu_init();
auto accu_init_expr = accu_init->mutable_ident_expr();
auto loop_condition = c->mutable_loop_condition();
auto loop_condition_expr = loop_condition->mutable_const_expr();
auto loop_step = c->mutable_loop_step();
auto loop_step_expr = loop_step->mutable_ident_expr();
auto result = c->mutable_result();
auto result_expr = result->mutable_const_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitComprehension(c, &expr, _)).Times(1);
EXPECT_CALL(handler,
PreVisitComprehensionSubexpression(iter_range, c, ITER_RANGE, _))
.Times(1);
EXPECT_CALL(handler, PostVisitConst(iter_range_expr, iter_range, _)).Times(1);
EXPECT_CALL(handler,
PostVisitComprehensionSubexpression(iter_range, c, ITER_RANGE, _))
.Times(1);
EXPECT_CALL(handler,
PreVisitComprehensionSubexpression(accu_init, c, ACCU_INIT, _))
.Times(1);
EXPECT_CALL(handler, PostVisitIdent(accu_init_expr, accu_init, _)).Times(1);
EXPECT_CALL(handler,
PostVisitComprehensionSubexpression(accu_init, c, ACCU_INIT, _))
.Times(1);
EXPECT_CALL(handler, PreVisitComprehensionSubexpression(loop_condition, c,
LOOP_CONDITION, _))
.Times(1);
EXPECT_CALL(handler, PostVisitConst(loop_condition_expr, loop_condition, _))
.Times(1);
EXPECT_CALL(handler, PostVisitComprehensionSubexpression(loop_condition, c,
LOOP_CONDITION, _))
.Times(1);
EXPECT_CALL(handler,
PreVisitComprehensionSubexpression(loop_step, c, LOOP_STEP, _))
.Times(1);
EXPECT_CALL(handler, PostVisitIdent(loop_step_expr, loop_step, _)).Times(1);
EXPECT_CALL(handler,
PostVisitComprehensionSubexpression(loop_step, c, LOOP_STEP, _))
.Times(1);
EXPECT_CALL(handler, PreVisitComprehensionSubexpression(result, c, RESULT, _))
.Times(1);
EXPECT_CALL(handler, PostVisitConst(result_expr, result, _)).Times(1);
EXPECT_CALL(handler,
PostVisitComprehensionSubexpression(result, c, RESULT, _))
.Times(1);
EXPECT_CALL(handler, PostVisitComprehension(c, &expr, _)).Times(1);
TraversalOptions opts;
opts.use_comprehension_callbacks = true;
AstTraverse(&expr, &source_info, &handler, opts);
}
TEST(AstCrawlerTest, CheckCrawlComprehensionLegacyCallbacks) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto c = expr.mutable_comprehension_expr();
auto iter_range = c->mutable_iter_range();
auto iter_range_expr = iter_range->mutable_const_expr();
auto accu_init = c->mutable_accu_init();
auto accu_init_expr = accu_init->mutable_ident_expr();
auto loop_condition = c->mutable_loop_condition();
auto loop_condition_expr = loop_condition->mutable_const_expr();
auto loop_step = c->mutable_loop_step();
auto loop_step_expr = loop_step->mutable_ident_expr();
auto result = c->mutable_result();
auto result_expr = result->mutable_const_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitComprehension(c, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(iter_range_expr, iter_range, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(ITER_RANGE, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(accu_init_expr, accu_init, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(ACCU_INIT, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(loop_condition_expr, loop_condition, _))
.Times(1);
EXPECT_CALL(handler, PostVisitArg(LOOP_CONDITION, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(loop_step_expr, loop_step, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(LOOP_STEP, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(result_expr, result, _)).Times(1);
EXPECT_CALL(handler, PostVisitArg(RESULT, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitComprehension(c, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCreateList) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto list_expr = expr.mutable_list_expr();
auto arg0 = list_expr->add_elements();
auto const_expr = arg0->mutable_const_expr();
auto arg1 = list_expr->add_elements();
auto ident_expr = arg1->mutable_ident_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitCreateList(list_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(const_expr, arg0, _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(ident_expr, arg1, _)).Times(1);
EXPECT_CALL(handler, PostVisitCreateList(list_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckCreateStruct) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto struct_expr = expr.mutable_struct_expr();
auto entry0 = struct_expr->add_entries();
auto key = entry0->mutable_map_key()->mutable_const_expr();
auto value = entry0->mutable_value()->mutable_ident_expr();
testing::InSequence seq;
EXPECT_CALL(handler, PreVisitCreateStruct(struct_expr, &expr, _)).Times(1);
EXPECT_CALL(handler, PostVisitConst(key, &entry0->map_key(), _)).Times(1);
EXPECT_CALL(handler, PostVisitIdent(value, &entry0->value(), _)).Times(1);
EXPECT_CALL(handler, PostVisitCreateStruct(struct_expr, &expr, _)).Times(1);
AstTraverse(&expr, &source_info, &handler);
}
TEST(AstCrawlerTest, CheckExprHandlers) {
SourceInfo source_info;
MockAstVisitor handler;
Expr expr;
auto struct_expr = expr.mutable_struct_expr();
auto entry0 = struct_expr->add_entries();
entry0->mutable_map_key()->mutable_const_expr();
entry0->mutable_value()->mutable_ident_expr();
EXPECT_CALL(handler, PreVisitExpr(_, _)).Times(3);
EXPECT_CALL(handler, PostVisitExpr(_, _)).Times(3);
AstTraverse(&expr, &source_info, &handler);
}
}
} | 8 |
#ifndef THIRD_PARTY_CEL_CPP_COMMON_SOURCE_H_
#define THIRD_PARTY_CEL_CPP_COMMON_SOURCE_H_
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include "absl/base/attributes.h"
#include "absl/base/nullability.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "absl/types/variant.h"
namespace cel {
namespace common_internal {
class SourceImpl;
}
class Source;
using SourcePosition = int32_t;
struct SourceRange final {
SourcePosition begin = -1;
SourcePosition end = -1;
};
inline bool operator==(const SourceRange& lhs, const SourceRange& rhs) {
return lhs.begin == rhs.begin && lhs.end == rhs.end;
}
inline bool operator!=(const SourceRange& lhs, const SourceRange& rhs) {
return !operator==(lhs, rhs);
}
struct SourceLocation final {
int32_t line = -1;
int32_t column = -1;
};
inline bool operator==(const SourceLocation& lhs, const SourceLocation& rhs) {
return lhs.line == rhs.line && lhs.column == rhs.column;
}
inline bool operator!=(const SourceLocation& lhs, const SourceLocation& rhs) {
return !operator==(lhs, rhs);
}
class SourceContentView final {
public:
SourceContentView(const SourceContentView&) = default;
SourceContentView(SourceContentView&&) = default;
SourceContentView& operator=(const SourceContentView&) = default;
SourceContentView& operator=(SourceContentView&&) = default;
SourcePosition size() const;
bool empty() const;
char32_t at(SourcePosition position) const;
std::string ToString(SourcePosition begin, SourcePosition end) const;
std::string ToString(SourcePosition begin) const {
return ToString(begin, size());
}
std::string ToString() const { return ToString(0); }
void AppendToString(std::string& dest) const;
private:
friend class Source;
constexpr SourceContentView() = default;
constexpr explicit SourceContentView(absl::Span<const char> view)
: view_(view) {}
constexpr explicit SourceContentView(absl::Span<const uint8_t> view)
: view_(view) {}
constexpr explicit SourceContentView(absl::Span<const char16_t> view)
: view_(view) {}
constexpr explicit SourceContentView(absl::Span<const char32_t> view)
: view_(view) {}
absl::variant<absl::Span<const char>, absl::Span<const uint8_t>,
absl::Span<const char16_t>, absl::Span<const char32_t>>
view_;
};
class Source {
public:
using ContentView = SourceContentView;
Source(const Source&) = delete;
Source(Source&&) = delete;
virtual ~Source() = default;
Source& operator=(const Source&) = delete;
Source& operator=(Source&&) = delete;
virtual absl::string_view description() const
ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;
absl::optional<SourceLocation> GetLocation(SourcePosition position) const;
absl::optional<SourcePosition> GetPosition(
const SourceLocation& location) const;
absl::optional<std::string> Snippet(int32_t line) const;
std::string DisplayErrorLocation(SourceLocation location) const;
virtual ContentView content() const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;
virtual absl::Span<const SourcePosition> line_offsets() const
ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;
protected:
static constexpr ContentView EmptyContentView() { return ContentView(); }
static constexpr ContentView MakeContentView(absl::Span<const char> view) {
return ContentView(view);
}
static constexpr ContentView MakeContentView(absl::Span<const uint8_t> view) {
return ContentView(view);
}
static constexpr ContentView MakeContentView(
absl::Span<const char16_t> view) {
return ContentView(view);
}
static constexpr ContentView MakeContentView(
absl::Span<const char32_t> view) {
return ContentView(view);
}
private:
friend class common_internal::SourceImpl;
Source() = default;
absl::optional<SourcePosition> FindLinePosition(int32_t line) const;
absl::optional<std::pair<int32_t, SourcePosition>> FindLine(
SourcePosition position) const;
};
using SourcePtr = std::unique_ptr<Source>;
absl::StatusOr<absl::Nonnull<SourcePtr>> NewSource(
absl::string_view content, std::string description = "<input>");
absl::StatusOr<absl::Nonnull<SourcePtr>> NewSource(
const absl::Cord& content, std::string description = "<input>");
}
#endif
#include "common/source.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "absl/base/nullability.h"
#include "absl/base/optimization.h"
#include "absl/container/inlined_vector.h"
#include "absl/functional/overload.h"
#include "absl/log/absl_check.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "absl/types/variant.h"
#include "internal/unicode.h"
#include "internal/utf8.h"
namespace cel {
SourcePosition SourceContentView::size() const {
return static_cast<SourcePosition>(absl::visit(
absl::Overload(
[](absl::Span<const char> view) { return view.size(); },
[](absl::Span<const uint8_t> view) { return view.size(); },
[](absl::Span<const char16_t> view) { return view.size(); },
[](absl::Span<const char32_t> view) { return view.size(); }),
view_));
}
bool SourceContentView::empty() const {
return absl::visit(
absl::Overload(
[](absl::Span<const char> view) { return view.empty(); },
[](absl::Span<const uint8_t> view) { return view.empty(); },
[](absl::Span<const char16_t> view) { return view.empty(); },
[](absl::Span<const char32_t> view) { return view.empty(); }),
view_);
}
char32_t SourceContentView::at(SourcePosition position) const {
ABSL_DCHECK_GE(position, 0);
ABSL_DCHECK_LT(position, size());
return absl::visit(
absl::Overload(
[position =
static_cast<size_t>(position)](absl::Span<const char> view) {
return static_cast<char32_t>(static_cast<uint8_t>(view[position]));
},
[position =
static_cast<size_t>(position)](absl::Span<const uint8_t> view) {
return static_cast<char32_t>(view[position]);
},
[position =
static_cast<size_t>(position)](absl::Span<const char16_t> view) {
return static_cast<char32_t>(view[position]);
},
[position =
static_cast<size_t>(position)](absl::Span<const char32_t> view) {
return static_cast<char32_t>(view[position]);
}),
view_);
}
std::string SourceContentView::ToString(SourcePosition begin,
SourcePosition end) const {
ABSL_DCHECK_GE(begin, 0);
ABSL_DCHECK_LE(end, size());
ABSL_DCHECK_LE(begin, end);
return absl::visit(
absl::Overload(
[begin = static_cast<size_t>(begin),
end = static_cast<size_t>(end)](absl::Span<const char> view) {
view = view.subspan(begin, end - begin);
return std::string(view.data(), view.size());
},
[begin = static_cast<size_t>(begin),
end = static_cast<size_t>(end)](absl::Span<const uint8_t> view) {
view = view.subspan(begin, end - begin);
std::string result;
result.reserve(view.size() * 2);
for (const auto& code_point : view) {
internal::Utf8Encode(result, code_point);
}
result.shrink_to_fit();
return result;
},
[begin = static_cast<size_t>(begin),
end = static_cast<size_t>(end)](absl::Span<const char16_t> view) {
view = view.subspan(begin, end - begin);
std::string result;
result.reserve(view.size() * 3);
for (const auto& code_point : view) {
internal::Utf8Encode(result, code_point);
}
result.shrink_to_fit();
return result;
},
[begin = static_cast<size_t>(begin),
end = static_cast<size_t>(end)](absl::Span<const char32_t> view) {
view = view.subspan(begin, end - begin);
std::string result;
result.reserve(view.size() * 4);
for (const auto& code_point : view) {
internal::Utf8Encode(result, code_point);
}
result.shrink_to_fit();
return result;
}),
view_);
}
void SourceContentView::AppendToString(std::string& dest) const {
absl::visit(absl::Overload(
[&dest](absl::Span<const char> view) {
dest.append(view.data(), view.size());
},
[&dest](absl::Span<const uint8_t> view) {
for (const auto& code_point : view) {
internal::Utf8Encode(dest, code_point);
}
},
[&dest](absl::Span<const char16_t> view) {
for (const auto& code_point : view) {
internal::Utf8Encode(dest, code_point);
}
},
[&dest](absl::Span<const char32_t> view) {
for (const auto& code_point : view) {
internal::Utf8Encode(dest, code_point);
}
}),
view_);
}
namespace common_internal {
class SourceImpl : public Source {
public:
SourceImpl(std::string description,
absl::InlinedVector<SourcePosition, 1> line_offsets)
: description_(std::move(description)),
line_offsets_(std::move(line_offsets)) {}
absl::string_view description() const final { return description_; }
absl::Span<const SourcePosition> line_offsets() const final {
return absl::MakeConstSpan(line_offsets_);
}
private:
const std::string description_;
const absl::InlinedVector<SourcePosition, 1> line_offsets_;
};
namespace {
class AsciiSource final : public SourceImpl {
public:
AsciiSource(std::string description,
absl::InlinedVector<SourcePosition, 1> line_offsets,
std::vector<char> text)
: SourceImpl(std::move(description), std::move(line_offsets)),
text_(std::move(text)) {}
ContentView content() const override {
return MakeContentView(absl::MakeConstSpan(text_));
}
private:
const std::vector<char> text_;
};
class Latin1Source final : public SourceImpl {
public:
Latin1Source(std::string description,
absl::InlinedVector<SourcePosition, 1> line_offsets,
std::vector<uint8_t> text)
: SourceImpl(std::move(description), std::move(line_offsets)),
text_(std::move(text)) {}
ContentView content() const override {
return MakeContentView(absl::MakeConstSpan(text_));
}
private:
const std::vector<uint8_t> text_;
};
class BasicPlaneSource final : public SourceImpl {
public:
BasicPlaneSource(std::string description,
absl::InlinedVector<SourcePosition, 1> line_offsets,
std::vector<char16_t> text)
: SourceImpl(std::move(description), std::move(line_offsets)),
text_(std::move(text)) {}
ContentView content() const override {
return MakeContentView(absl::MakeConstSpan(text_));
}
private:
const std::vector<char16_t> text_;
};
class SupplementalPlaneSource final : public SourceImpl {
public:
SupplementalPlaneSource(std::string description,
absl::InlinedVector<SourcePosition, 1> line_offsets,
std::vector<char32_t> text)
: SourceImpl(std::move(description), std::move(line_offsets)),
text_(std::move(text)) {}
ContentView content() const override {
return MakeContentView(absl::MakeConstSpan(text_));
}
private:
const std::vector<char32_t> text_;
};
template <typename T>
struct SourceTextTraits;
template <>
struct SourceTextTraits<absl::string_view> {
using iterator_type = absl::string_view;
static iterator_type Begin(absl::string_view text) { return text; }
static void Advance(iterator_type& it, size_t n) { it.remove_prefix(n); }
static void AppendTo(std::vector<uint8_t>& out, absl::string_view text,
size_t n) {
const auto* in = reinterpret_cast<const uint8_t*>(text.data());
out.insert(out.end(), in, in + n);
}
static std::vector<char> ToVector(absl::string_view in) {
std::vector<char> out;
out.reserve(in.size());
out.insert(out.end(), in.begin(), in.end());
return out;
}
};
template <>
struct SourceTextTraits<absl::Cord> {
using iterator_type = absl::Cord::CharIterator;
static iterator_type Begin(const absl::Cord& text) {
return text.char_begin();
}
static void Advance(iterator_type& it, size_t n) {
absl::Cord::Advance(&it, n);
}
static void AppendTo(std::vector<uint8_t>& out, const absl::Cord& text,
size_t n) {
auto it = text.char_begin();
while (n > 0) {
auto str = absl::Cord::ChunkRemaining(it);
size_t to_append = std::min(n, str.size());
const auto* in = reinterpret_cast<const uint8_t*>(str.data());
out.insert(out.end(), in, in + to_append);
n -= to_append;
absl::Cord::Advance(&it, to_append);
}
}
static std::vector<char> ToVector(const absl::Cord& in) {
std::vector<char> out;
out.reserve(in.size());
for (const auto& chunk : in.Chunks()) {
out.insert(out.end(), chunk.begin(), chunk.end());
}
return out;
}
};
template <typename T>
absl::StatusOr<SourcePtr> NewSourceImpl(std::string description, const T& text,
const size_t text_size) {
if (ABSL_PREDICT_FALSE(
text_size >
static_cast<size_t>(std::numeric_limits<int32_t>::max()))) {
return absl::InvalidArgumentError("expression larger than 2GiB limit");
}
using Traits = SourceTextTraits<T>;
size_t index = 0;
typename Traits::iterator_type it = Traits::Begin(text);
SourcePosition offset = 0;
char32_t code_point;
size_t code_units;
std::vector<uint8_t> data8;
std::vector<char16_t> data16;
std::vector<char32_t> data32;
absl::InlinedVector<SourcePosition, 1> line_offsets;
while (index < text_size) {
std::tie(code_point, code_units) = cel::internal::Utf8Decode(it);
if (ABSL_PREDICT_FALSE(code_point ==
cel::internal::kUnicodeReplacementCharacter &&
code_units == 1)) {
return absl::InvalidArgumentError("cannot parse malformed UTF-8 input");
}
if (code_point == '\n') {
line_offsets.push_back(offset + 1);
}
if (code_point <= 0x7f) {
Traits::Advance(it, code_units);
index += code_units;
++offset;
continue;
}
if (code_point <= 0xff) {
data8.reserve(text_size);
Traits::AppendTo(data8, text, index);
data8.push_back(static_cast<uint8_t>(code_point));
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto latin1;
}
if (code_point <= 0xffff) {
data16.reserve(text_size);
for (size_t offset = 0; offset < index; offset++) {
data16.push_back(static_cast<uint8_t>(text[offset]));
}
data16.push_back(static_cast<char16_t>(code_point));
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto basic;
}
data32.reserve(text_size);
for (size_t offset = 0; offset < index; offset++) {
data32.push_back(static_cast<char32_t>(text[offset]));
}
data32.push_back(code_point);
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto supplemental;
}
line_offsets.push_back(offset + 1);
return std::make_unique<AsciiSource>(
std::move(description), std::move(line_offsets), Traits::ToVector(text));
latin1:
while (index < text_size) {
std::tie(code_point, code_units) = internal::Utf8Decode(it);
if (ABSL_PREDICT_FALSE(code_point ==
internal::kUnicodeReplacementCharacter &&
code_units == 1)) {
return absl::InvalidArgumentError("cannot parse malformed UTF-8 input");
}
if (code_point == '\n') {
line_offsets.push_back(offset + 1);
}
if (code_point <= 0xff) {
data8.push_back(static_cast<uint8_t>(code_point));
Traits::Advance(it, code_units);
index += code_units;
++offset;
continue;
}
if (code_point <= 0xffff) {
data16.reserve(text_size);
for (const auto& value : data8) {
data16.push_back(value);
}
std::vector<uint8_t>().swap(data8);
data16.push_back(static_cast<char16_t>(code_point));
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto basic;
}
data32.reserve(text_size);
for (const auto& value : data8) {
data32.push_back(value);
}
std::vector<uint8_t>().swap(data8);
data32.push_back(code_point);
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto supplemental;
}
line_offsets.push_back(offset + 1);
return std::make_unique<Latin1Source>(
std::move(description), std::move(line_offsets), std::move(data8));
basic:
while (index < text_size) {
std::tie(code_point, code_units) = internal::Utf8Decode(it);
if (ABSL_PREDICT_FALSE(code_point ==
internal::kUnicodeReplacementCharacter &&
code_units == 1)) {
return absl::InvalidArgumentError("cannot parse malformed UTF-8 input");
}
if (code_point == '\n') {
line_offsets.push_back(offset + 1);
}
if (code_point <= 0xffff) {
data16.push_back(static_cast<char16_t>(code_point));
Traits::Advance(it, code_units);
index += code_units;
++offset;
continue;
}
data32.reserve(text_size);
for (const auto& value : data16) {
data32.push_back(static_cast<char32_t>(value));
}
std::vector<char16_t>().swap(data16);
data32.push_back(code_point);
Traits::Advance(it, code_units);
index += code_units;
++offset;
goto supplemental;
}
line_offsets.push_back(offset + 1);
return std::make_unique<BasicPlaneSource>(
std::move(description), std::move(line_offsets), std::move(data16));
supplemental:
while (index < text_size) {
std::tie(code_point, code_units) = internal::Utf8Decode(it);
if (ABSL_PREDICT_FALSE(code_point ==
internal::kUnicodeReplacementCharacter &&
code_units == 1)) {
return absl::InvalidArgumentError("cannot parse malformed UTF-8 input");
}
if (code_point == '\n') {
line_offsets.push_back(offset + 1);
}
data32.push_back(code_point);
Traits::Advance(it, code_units);
index += code_units;
++offset;
}
line_offsets.push_back(offset + 1);
return std::make_unique<SupplementalPlaneSource>(
std::move(description), std::move(line_offsets), std::move(data32));
}
}
}
absl::optional<SourceLocation> Source::GetLocation(
SourcePosition position) const {
if (auto line_and_offset = FindLine(position);
ABSL_PREDICT_TRUE(line_and_offset.has_value())) {
return SourceLocation{line_and_offset->first,
position - line_and_offset->second};
}
return absl::nullopt;
}
absl::optional<SourcePosition> Source::GetPosition(
const SourceLocation& location) const {
if (ABSL_PREDICT_FALSE(location.line < 1 || location.column < 0)) {
return absl::nullopt;
}
if (auto position = FindLinePosition(location.line);
ABSL_PREDICT_TRUE(position.has_value())) {
return *position + location.column;
}
return absl::nullopt;
}
absl::optional<std::string> Source::Snippet(int32_t line) const {
auto content = this->content();
auto start = FindLinePosition(line);
if (ABSL_PREDICT_FALSE(!start.has_value() || content.empty())) {
return absl::nullopt;
}
auto end = FindLinePosition(line + 1);
if (end.has_value()) {
return content.ToString(*start, *end - 1);
}
return content.ToString(*start);
}
std::string Source::DisplayErrorLocation(SourceLocation location) const {
constexpr char32_t kDot = '.';
constexpr char32_t kHat = '^';
constexpr char32_t kWideDot = 0xff0e;
constexpr char32_t kWideHat = 0xff3e;
absl::optional<std::string> snippet = Snippet(location.line);
if (!snippet || snippet->empty()) {
return "";
}
*snippet = absl::StrReplaceAll(*snippet, {{"\t", " "}});
absl::string_view snippet_view(*snippet);
std::string result;
absl::StrAppend(&result, "\n | ", *snippet);
absl::StrAppend(&result, "\n | ");
std::string index_line;
for (int32_t i = 0; i < location.column && !snippet_view.empty(); ++i) {
size_t count;
std::tie(std::ignore, count) = internal::Utf8Decode(snippet_view);
snippet_view.remove_prefix(count);
if (count > 1) {
internal::Utf8Encode(index_line, kWideDot);
} else {
internal::Utf8Encode(index_line, kDot);
}
}
size_t count = 0;
if (!snippet_view.empty()) {
std::tie(std::ignore, count) = internal::Utf8Decode(snippet_view);
}
if (count > 1) {
internal::Utf8Encode(index_line, kWideHat);
} else {
internal::Utf8Encode(index_line, kHat);
}
absl::StrAppend(&result, index_line);
return result;
}
absl::optional<SourcePosition> Source::FindLinePosition(int32_t line) const {
if (ABSL_PREDICT_FALSE(line < 1)) {
return absl::nullopt;
}
if (line == 1) {
return SourcePosition{0};
}
const auto line_offsets = this->line_offsets();
if (ABSL_PREDICT_TRUE(line <= static_cast<int32_t>(line_offsets.size()))) {
return line_offsets[static_cast<size_t>(line - 2)];
}
return absl::nullopt;
}
absl::optional<std::pair<int32_t, SourcePosition>> Source::FindLine(
SourcePosition position) const {
if (ABSL_PREDICT_FALSE(position < 0)) {
return absl::nullopt;
}
int32_t line = 1;
const auto line_offsets = this->line_offsets();
for (const auto& line_offset : line_offsets) {
if (line_offset > position) {
break;
}
++line;
}
if (line == 1) {
return std::make_pair(line, SourcePosition{0});
}
return std::make_pair(line, line_offsets[static_cast<size_t>(line) - 2]);
}
absl::StatusOr<absl::Nonnull<SourcePtr>> NewSource(absl::string_view content,
std::string description) {
return common_internal::NewSourceImpl(std::move(description), content,
content.size());
}
absl::StatusOr<absl::Nonnull<SourcePtr>> NewSource(const absl::Cord& content,
std::string description) {
return common_internal::NewSourceImpl(std::move(description), content,
content.size());
}
} | #include "common/source.h"
#include "absl/strings/cord.h"
#include "absl/types/optional.h"
#include "internal/testing.h"
namespace cel {
namespace {
using testing::ElementsAre;
using testing::Eq;
using testing::Ne;
using testing::Optional;
TEST(SourceRange, Default) {
SourceRange range;
EXPECT_EQ(range.begin, -1);
EXPECT_EQ(range.end, -1);
}
TEST(SourceRange, Equality) {
EXPECT_THAT((SourceRange{}), (Eq(SourceRange{})));
EXPECT_THAT((SourceRange{0, 1}), (Ne(SourceRange{0, 0})));
}
TEST(SourceLocation, Default) {
SourceLocation location;
EXPECT_EQ(location.line, -1);
EXPECT_EQ(location.column, -1);
}
TEST(SourceLocation, Equality) {
EXPECT_THAT((SourceLocation{}), (Eq(SourceLocation{})));
EXPECT_THAT((SourceLocation{1, 1}), (Ne(SourceLocation{1, 0})));
}
TEST(StringSource, Description) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource("c.d &&\n\t b.c.arg(10) &&\n\t test(10)", "offset-test"));
EXPECT_THAT(source->description(), Eq("offset-test"));
}
TEST(StringSource, Content) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource("c.d &&\n\t b.c.arg(10) &&\n\t test(10)", "offset-test"));
EXPECT_THAT(source->content().ToString(),
Eq("c.d &&\n\t b.c.arg(10) &&\n\t test(10)"));
}
TEST(StringSource, PositionAndLocation) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource("c.d &&\n\t b.c.arg(10) &&\n\t test(10)", "offset-test"));
EXPECT_THAT(source->line_offsets(), ElementsAre(7, 24, 35));
auto start = source->GetPosition(SourceLocation{int32_t{1}, int32_t{2}});
auto end = source->GetPosition(SourceLocation{int32_t{3}, int32_t{2}});
ASSERT_TRUE(start.has_value());
ASSERT_TRUE(end.has_value());
EXPECT_THAT(source->GetLocation(*start),
Optional(Eq(SourceLocation{int32_t{1}, int32_t{2}})));
EXPECT_THAT(source->GetLocation(*end),
Optional(Eq(SourceLocation{int32_t{3}, int32_t{2}})));
EXPECT_THAT(source->GetLocation(-1), Eq(absl::nullopt));
EXPECT_THAT(source->content().ToString(*start, *end),
Eq("d &&\n\t b.c.arg(10) &&\n\t "));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{0}, int32_t{0}}),
Eq(absl::nullopt));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{1}, int32_t{-1}}),
Eq(absl::nullopt));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{4}, int32_t{0}}),
Eq(absl::nullopt));
}
TEST(StringSource, SnippetSingle) {
ASSERT_OK_AND_ASSIGN(auto source, NewSource("hello, world", "one-line-test"));
EXPECT_THAT(source->Snippet(1), Optional(Eq("hello, world")));
EXPECT_THAT(source->Snippet(2), Eq(absl::nullopt));
}
TEST(StringSource, SnippetMulti) {
ASSERT_OK_AND_ASSIGN(auto source,
NewSource("hello\nworld\nmy\nbub\n", "four-line-test"));
EXPECT_THAT(source->Snippet(0), Eq(absl::nullopt));
EXPECT_THAT(source->Snippet(1), Optional(Eq("hello")));
EXPECT_THAT(source->Snippet(2), Optional(Eq("world")));
EXPECT_THAT(source->Snippet(3), Optional(Eq("my")));
EXPECT_THAT(source->Snippet(4), Optional(Eq("bub")));
EXPECT_THAT(source->Snippet(5), Optional(Eq("")));
EXPECT_THAT(source->Snippet(6), Eq(absl::nullopt));
}
TEST(CordSource, Description) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource(absl::Cord("c.d &&\n\t b.c.arg(10) &&\n\t test(10)"),
"offset-test"));
EXPECT_THAT(source->description(), Eq("offset-test"));
}
TEST(CordSource, Content) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource(absl::Cord("c.d &&\n\t b.c.arg(10) &&\n\t test(10)"),
"offset-test"));
EXPECT_THAT(source->content().ToString(),
Eq("c.d &&\n\t b.c.arg(10) &&\n\t test(10)"));
}
TEST(CordSource, PositionAndLocation) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource(absl::Cord("c.d &&\n\t b.c.arg(10) &&\n\t test(10)"),
"offset-test"));
EXPECT_THAT(source->line_offsets(), ElementsAre(7, 24, 35));
auto start = source->GetPosition(SourceLocation{int32_t{1}, int32_t{2}});
auto end = source->GetPosition(SourceLocation{int32_t{3}, int32_t{2}});
ASSERT_TRUE(start.has_value());
ASSERT_TRUE(end.has_value());
EXPECT_THAT(source->GetLocation(*start),
Optional(Eq(SourceLocation{int32_t{1}, int32_t{2}})));
EXPECT_THAT(source->GetLocation(*end),
Optional(Eq(SourceLocation{int32_t{3}, int32_t{2}})));
EXPECT_THAT(source->GetLocation(-1), Eq(absl::nullopt));
EXPECT_THAT(source->content().ToString(*start, *end),
Eq("d &&\n\t b.c.arg(10) &&\n\t "));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{0}, int32_t{0}}),
Eq(absl::nullopt));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{1}, int32_t{-1}}),
Eq(absl::nullopt));
EXPECT_THAT(source->GetPosition(SourceLocation{int32_t{4}, int32_t{0}}),
Eq(absl::nullopt));
}
TEST(CordSource, SnippetSingle) {
ASSERT_OK_AND_ASSIGN(auto source,
NewSource(absl::Cord("hello, world"), "one-line-test"));
EXPECT_THAT(source->Snippet(1), Optional(Eq("hello, world")));
EXPECT_THAT(source->Snippet(2), Eq(absl::nullopt));
}
TEST(CordSource, SnippetMulti) {
ASSERT_OK_AND_ASSIGN(
auto source,
NewSource(absl::Cord("hello\nworld\nmy\nbub\n"), "four-line-test"));
EXPECT_THAT(source->Snippet(0), Eq(absl::nullopt));
EXPECT_THAT(source->Snippet(1), Optional(Eq("hello")));
EXPECT_THAT(source->Snippet(2), Optional(Eq("world")));
EXPECT_THAT(source->Snippet(3), Optional(Eq("my")));
EXPECT_THAT(source->Snippet(4), Optional(Eq("bub")));
EXPECT_THAT(source->Snippet(5), Optional(Eq("")));
EXPECT_THAT(source->Snippet(6), Eq(absl::nullopt));
}
TEST(Source, DisplayErrorLocationBasic) {
ASSERT_OK_AND_ASSIGN(auto source, NewSource("'Hello' +\n 'world'"));
SourceLocation location{2, 3};
EXPECT_EQ(source->DisplayErrorLocation(location),
"\n | 'world'"
"\n | ...^");
}
TEST(Source, DisplayErrorLocationOutOfRange) {
ASSERT_OK_AND_ASSIGN(auto source, NewSource("'Hello world!'"));
SourceLocation location{3, 3};
EXPECT_EQ(source->DisplayErrorLocation(location), "");
}
TEST(Source, DisplayErrorLocationTabsShortened) {
ASSERT_OK_AND_ASSIGN(auto source, NewSource("'Hello' +\n\t\t'world!'"));
SourceLocation location{2, 4};
EXPECT_EQ(source->DisplayErrorLocation(location),
"\n | 'world!'"
"\n | ....^");
}
TEST(Source, DisplayErrorLocationFullWidth) {
ASSERT_OK_AND_ASSIGN(auto source, NewSource("'Ｈｅｌｌｏ'"));
SourceLocation location{1, 2};
EXPECT_EQ(source->DisplayErrorLocation(location),
"\n | 'Ｈｅｌｌｏ'"
"\n | .．＾");
}
}
} | 9 |
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 47
Size of downloaded dataset files:
3.34 MB
Size of the auto-converted Parquet files:
3.34 MB
Number of rows:
615