Support deserializing tagged literal scalar into primitive

dtolnay · Sep 14, 2022 · bfff6c1 · bfff6c1
1 parent f41036c
commit bfff6c1
Showing 1 changed file with 44 additions and 6 deletions.
diff --git a/src/de.rs b/src/de.rs
@@ -1149,6 +1149,26 @@ where
     }
 }
 
+fn is_plain_or_tagged_literal_scalar(
+    expected: &str,
+    scalar: &Scalar,
+    tagged_already: bool,
+) -> bool {
+    if scalar.style == ScalarStyle::Plain {
+        return true;
+    }
+    if tagged_already {
+        return false;
+    }
+    if scalar.style != ScalarStyle::Literal {
+        return false;
+    }
+    if let Some(tag) = &scalar.tag {
+        return tag == expected;
+    }
+    false
+}
+
 fn invalid_type(event: &Event, exp: &dyn Expected) -> Error {
     enum Void {}
 
@@ -1250,11 +1270,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_bool(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::BOOL, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(boolean) = parse_bool(value) {
                             break visitor.visit_bool(boolean);
@@ -1293,11 +1316,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_i64(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::INT, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(int) = parse_signed_int(value, i64::from_str_radix) {
                             break visitor.visit_i64(int);
@@ -1315,11 +1341,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_i128(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::INT, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(int) = parse_signed_int(value, i128::from_str_radix) {
                             break visitor.visit_i128(int);
@@ -1358,11 +1387,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_u64(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::INT, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(int) = parse_unsigned_int(value, u64::from_str_radix) {
                             break visitor.visit_u64(int);
@@ -1380,11 +1412,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_u128(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::INT, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(int) = parse_unsigned_int(value, u128::from_str_radix) {
                             break visitor.visit_u128(int);
@@ -1409,11 +1444,14 @@ impl<'de, 'document> de::Deserializer<'de> for &mut DeserializerFromEvents<'de,
     where
         V: Visitor<'de>,
     {
+        let tagged_already = self.current_enum.is_some();
         let (next, mark) = self.next_event_mark()?;
         loop {
             match next {
                 Event::Alias(mut pos) => break self.jump(&mut pos)?.deserialize_f64(visitor),
-                Event::Scalar(scalar) if scalar.style == ScalarStyle::Plain => {
+                Event::Scalar(scalar)
+                    if is_plain_or_tagged_literal_scalar(Tag::FLOAT, scalar, tagged_already) =>
+                {
                     if let Ok(value) = str::from_utf8(&scalar.value) {
                         if let Some(float) = parse_f64(value) {
                             break visitor.visit_f64(float);