#include "rapidproto/features.hpp"
#include <algorithm>
#include <array>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
#include "rapidproto/result.hpp"
#include "rapidproto/ast.hpp"
#include "rapidproto/resolver.hpp"
#include "rapidproto/scalar.hpp"
namespace rapidproto {
namespace {
struct ResolvedFeatures {
FieldPresence field_presence = FieldPresence::Explicit;
EnumOpenness enum_type = EnumOpenness::Open;
MessageEncoding message_encoding = MessageEncoding::LengthPrefixed;
RepeatedEncoding repeated_field_encoding = RepeatedEncoding::Packed;
bool utf8_validation_verify = true;
};
constexpr std::array<std::string_view, 2> kKnownEditions = {"2023", "2024"};
bool is_known_edition(std::string_view edition) {
return std::find(kKnownEditions.begin(), kKnownEditions.end(), edition) != kKnownEditions.end();
}
ResolvedFeatures edition_defaults(const std::string& ) {
return ResolvedFeatures{};
}
void apply_one_feature(const std::string& name, const std::string& value, ResolvedFeatures& out) {
if (name == "field_presence") {
if (value == "EXPLICIT") {
out.field_presence = FieldPresence::Explicit;
} else if (value == "IMPLICIT") {
out.field_presence = FieldPresence::Implicit;
} else if (value == "LEGACY_REQUIRED") {
out.field_presence = FieldPresence::Required;
}
} else if (name == "enum_type") {
if (value == "OPEN") {
out.enum_type = EnumOpenness::Open;
} else if (value == "CLOSED") {
out.enum_type = EnumOpenness::Closed;
}
} else if (name == "repeated_field_encoding") {
if (value == "PACKED") {
out.repeated_field_encoding = RepeatedEncoding::Packed;
} else if (value == "EXPANDED") {
out.repeated_field_encoding = RepeatedEncoding::Expanded;
}
} else if (name == "message_encoding") {
if (value == "LENGTH_PREFIXED") {
out.message_encoding = MessageEncoding::LengthPrefixed;
} else if (value == "DELIMITED") {
out.message_encoding = MessageEncoding::Delimited;
}
} else if (name == "utf8_validation") {
if (value == "VERIFY") {
out.utf8_validation_verify = true;
} else if (value == "NONE") {
out.utf8_validation_verify = false;
}
}
}
void apply_aggregate_features(const MessageLiteral& literal, ResolvedFeatures& out) {
for (const MessageLiteralField& field : literal.fields) {
if (field.name_kind != MessageFieldNameKind::Simple) {
continue; }
if (const auto* value = std::get_if<Identifier>(&field.value.value)) {
apply_one_feature(field.name, value->name, out);
}
}
}
void apply_features(const std::vector<Option>& options, ResolvedFeatures& out) {
for (const Option& option : options) {
if (option.name.empty() || option.name[0].is_extension ||
option.name[0].name != "features") {
continue;
}
if (option.name.size() == 1) {
if (const auto* literal = std::get_if<MessageLiteral>(&option.value.value)) {
apply_aggregate_features(*literal, out);
}
} else if (option.name.size() == 2) {
if (const auto* value = std::get_if<Identifier>(&option.value.value)) {
apply_one_feature(option.name[1].name, value->name, out);
}
}
}
}
void resolve_field(FieldNode& field, ResolvedFeatures scope, bool is_oneof_member) {
apply_features(field.options, scope);
if (!is_oneof_member) {
field.presence = scope.field_presence; }
if (!field.is_group) {
field.message_encoding = scope.message_encoding;
}
if (field.is_repeated && is_packable_scalar(field.type_name)) {
field.repeated_encoding = scope.repeated_field_encoding;
}
}
void resolve_enum(EnumNode& node, ResolvedFeatures scope) {
apply_features(node.options, scope);
node.openness = scope.enum_type;
}
void resolve_extend(ExtendNode& node, ResolvedFeatures scope) {
for (auto& field : node.fields) {
resolve_field(field, scope, false);
}
}
void resolve_message(MessageNode& message, ResolvedFeatures scope) {
apply_features(message.options, scope);
for (auto& field : message.fields) {
resolve_field(field, scope, false);
}
for (auto& oneof : message.oneofs) {
ResolvedFeatures oneof_scope = scope;
apply_features(oneof.options, oneof_scope);
for (auto& field : oneof.fields) {
resolve_field(field, oneof_scope, true);
}
}
for (auto& node : message.enums) {
resolve_enum(node, scope);
}
for (auto& nested : message.nested_messages) {
resolve_message(nested, scope);
}
for (auto& extend : message.extends) {
resolve_extend(extend, scope);
}
}
}
Result<std::monostate> resolve_features(FileNode& file) {
if (file.syntax_level != SyntaxLevel::Edition) {
return std::monostate{}; }
if (!is_known_edition(file.edition)) {
std::string known;
for (const std::string_view name : kKnownEditions) {
known += known.empty() ? "" : ", ";
known += name;
}
return Error{file.source, file.edition_offset,
"unknown edition \"" + file.edition +
"\"; this decoder knows the feature defaults for " + known +
" only, and a later edition may change one -- decoding it by those rules "
"could be silently wrong"};
}
ResolvedFeatures scope = edition_defaults(file.edition);
apply_features(file.options, scope);
for (auto& message : file.messages) {
resolve_message(message, scope);
}
for (auto& node : file.enums) {
resolve_enum(node, scope);
}
for (auto& extend : file.extends) {
resolve_extend(extend, scope);
}
return std::monostate{};
}
Result<std::monostate> resolve_features(ResolvedFileSet& file_set) {
for (auto& file : file_set.files) {
if (auto resolved = resolve_features(file); !resolved) {
return std::move(resolved).error();
}
}
return std::monostate{};
}
}