Function ConvertProtoSourceInfoToNative

common/ast_proto.cc:64–108

}

absl::StatusOr<SourceInfo> ConvertProtoSourceInfoToNative(
    const cel::expr::SourceInfo& source_info) {
  absl::flat_hash_map<int64_t, Expr> macro_calls;
  for (const auto& pair : source_info.macro_calls()) {
    auto native_expr = ExprValueFromProto(pair.second);
    if (!native_expr.ok()) {
      return native_expr.status();
    }
    macro_calls.emplace(pair.first, *(std::move(native_expr)));
  }
  std::vector<ExtensionSpec> extensions;
  extensions.reserve(source_info.extensions_size());
  for (const auto& extension : source_info.extensions()) {
    std::vector<ExtensionSpec::Component> components;
    components.reserve(extension.affected_components().size());
    for (const auto& component : extension.affected_components()) {
      switch (component) {
        case ExtensionPb::COMPONENT_PARSER:
          components.push_back(ExtensionSpec::Component::kParser);
          break;
        case ExtensionPb::COMPONENT_TYPE_CHECKER:
          components.push_back(ExtensionSpec::Component::kTypeChecker);
          break;
        case ExtensionPb::COMPONENT_RUNTIME:
          components.push_back(ExtensionSpec::Component::kRuntime);
          break;
        default:
          components.push_back(ExtensionSpec::Component::kUnspecified);
          break;
      }
    }
    extensions.push_back(ExtensionSpec(
        extension.id(),
        std::make_unique<ExtensionSpec::Version>(extension.version().major(),
                                                 extension.version().minor()),
        std::move(components)));
  }
  return SourceInfo(
      source_info.syntax_version(), source_info.location(),
      std::vector<int32_t>(source_info.line_offsets().begin(),
                           source_info.line_offsets().end()),
      absl::flat_hash_map<int64_t, int32_t>(source_info.positions().begin(),
                                            source_info.positions().end()),
      std::move(macro_calls), std::move(extensions));
}

absl::StatusOr<TypeSpec> ConvertProtoTypeToNative(
    const cel::expr::Type& type);