Upgrade to bitflags 2.0

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Depend on `serde_derive` directly to potentially enable more compilation parallelism ([#441](https://github.com/ron-rs/ron/pull/441))
 - Add `compact_maps` and `compact_structs` options to `PrettyConfig` to allow serialising maps and structs on a single line ([#448](https://github.com/ron-rs/ron/pull/448))
 - Add minimal support for `#[serde(flatten)]` with roundtripping through RON maps ([#455](https://github.com/ron-rs/ron/pull/455))
+- Breaking: Bump `bitflags` dependency to 2.0, changes `serde` impls of `Extensions` ([#443](https://github.com/ron-rs/ron/pull/443))
 
 ## [0.8.0] - 2022-08-17
 

Cargo.toml

@@ -25,7 +25,7 @@ integer128 = []
 
 [dependencies]
 base64 = "0.21"
-bitflags = "1.3"
+bitflags = { version = "2.0", features = ["serde"] }
 indexmap = { version = "1.9", features = ["serde-1"], optional = true }
 # serde supports i128/u128 from 1.0.60 onwards
 serde = "1.0.60"
@@ -35,5 +35,4 @@ serde_derive = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_bytes = "0.11"
 serde_json = "1.0"
-bitflags-serial = { git = "https://github.com/kvark/bitflags-serial" }
 option_set = "0.1"

src/de/mod.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use base64::Engine;
-use serde::de::{self, DeserializeSeed, Deserializer as SerdeError, Visitor};
+use serde::de::{self, DeserializeSeed, Deserializer as _, Visitor};
 
 use self::{id::IdDeserializer, tag::TagDeserializer};
 pub use crate::error::{Error, Position, SpannedError};

src/extensions.rs

@@ -1,7 +1,7 @@
 use serde_derive::{Deserialize, Serialize};
 
 bitflags::bitflags! {
-    #[derive(Serialize, Deserialize)]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
     pub struct Extensions: usize {
         const UNWRAP_NEWTYPES = 0x1;
         const IMPLICIT_SOME = 0x2;

src/value/raw.rs

@@ -125,7 +125,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue {
             }
 
             fn visit_borrowed_str<E: de::Error>(self, ron: &'de str) -> Result<Self::Value, E> {
-                match Options::default().from_str::<serde::de::IgnoredAny>(ron) {
+                match Options::default().from_str::<de::IgnoredAny>(ron) {
                     Ok(_) => Ok(RawValue::from_borrowed_str(ron)),
                     Err(err) => Err(de::Error::custom(format!(
                         "invalid RON value at {}: {}",
@@ -159,7 +159,7 @@ impl<'de> Deserialize<'de> for Box<RawValue> {
             }
 
             fn visit_str<E: de::Error>(self, ron: &str) -> Result<Self::Value, E> {
-                match Options::default().from_str::<serde::de::IgnoredAny>(ron) {
+                match Options::default().from_str::<de::IgnoredAny>(ron) {
                     Ok(_) => Ok(RawValue::from_boxed_str(ron.to_owned().into_boxed_str())),
                     Err(err) => Err(de::Error::custom(format!(
                         "invalid RON value at {}: {}",
@@ -169,7 +169,7 @@ impl<'de> Deserialize<'de> for Box<RawValue> {
             }
 
             fn visit_string<E: de::Error>(self, ron: String) -> Result<Self::Value, E> {
-                match Options::default().from_str::<serde::de::IgnoredAny>(&ron) {
+                match Options::default().from_str::<de::IgnoredAny>(&ron) {
                     Ok(_) => Ok(RawValue::from_boxed_str(ron.into_boxed_str())),
                     Err(err) => Err(de::Error::custom(format!(
                         "invalid RON value at {}: {}",

tests/152_bitflags.rs

@@ -1,11 +1,11 @@
 use bitflags::*;
 use option_set::option_set;
 
-#[macro_use]
-extern crate bitflags_serial;
-
 bitflags! {
-    #[derive(serde::Serialize, serde::Deserialize)]
+    #[derive(
+        Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash,
+        serde::Serialize, serde::Deserialize,
+    )]
     struct TestGood: u8 {
         const ONE = 1;
         const TWO = 1 << 1;
@@ -14,21 +14,14 @@ bitflags! {
 }
 
 option_set! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     struct TestBad: UpperCamel + u8 {
         const ONE = 1;
         const TWO = 1 << 1;
         const THREE  = 1 << 2;
     }
 }
 
-bitflags_serial! {
-    struct TestBadTWO: u8 {
-        const ONE = 1;
-        const TWO = 1 << 1;
-        const THREE  = 1 << 2;
-    }
-}
-
 #[test]
 fn test_bitflags() {
     // Test case provided by jaynus in
@@ -39,8 +32,8 @@ fn test_bitflags() {
     let json_ser_good = serde_json::ser::to_string(&flag_good).unwrap();
     let ron_ser_good = ron::ser::to_string(&flag_good).unwrap();
 
-    assert_eq!(json_ser_good, "{\"bits\":3}");
-    assert_eq!(ron_ser_good, "(bits:3)");
+    assert_eq!(json_ser_good, "\"ONE | TWO\"");
+    assert_eq!(ron_ser_good, "(\"ONE | TWO\")");
 
     let json_de_good: TestGood = serde_json::de::from_str(json_ser_good.as_str()).unwrap();
     let ron_de_good: TestGood = ron::de::from_str(ron_ser_good.as_str()).unwrap();
@@ -62,19 +55,4 @@ fn test_bitflags() {
 
     assert_eq!(json_de_bad, flag_bad);
     assert_eq!(ron_de_bad, flag_bad);
-
-    // bitflags_serial
-    let flag_bad_two = TestBadTWO::ONE | TestBadTWO::TWO;
-
-    let json_ser_bad_two = serde_json::ser::to_string(&flag_bad_two).unwrap();
-    let ron_ser_bad_two = ron::ser::to_string(&flag_bad_two).unwrap();
-
-    assert_eq!(json_ser_bad_two, "[\"ONE\",\"TWO\"]");
-    assert_eq!(ron_ser_bad_two, "[ONE,TWO]");
-
-    let json_de_bad_two: TestBadTWO = serde_json::de::from_str(json_ser_bad_two.as_str()).unwrap();
-    let ron_de_bad_two: TestBadTWO = ron::de::from_str(ron_ser_bad_two.as_str()).unwrap();
-
-    assert_eq!(json_de_bad_two, flag_bad_two);
-    assert_eq!(ron_de_bad_two, flag_bad_two);
 }