tweak parse_json (#207)

* tweak parse_json

* further tweaks

Author: samuelcolvin

src/input/input_python.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::str::from_utf8;
 
 use pyo3::exceptions::PyAttributeError;
@@ -159,8 +160,8 @@ impl<'a> Input<'a> for PyAny {
     fn lax_bool(&self) -> ValResult<bool> {
         if let Ok(bool) = self.extract::<bool>() {
             Ok(bool)
-        } else if let Some(either_str) = maybe_as_string(self, ErrorKind::BoolParsing)? {
-            str_as_bool(self, &either_str.as_cow())
+        } else if let Some(cow_str) = maybe_as_string(self, ErrorKind::BoolParsing)? {
+            str_as_bool(self, &cow_str)
         } else if let Ok(int) = self.extract::<i64>() {
             int_as_bool(self, int)
         } else if let Ok(float) = self.extract::<f64>() {
@@ -187,8 +188,8 @@ impl<'a> Input<'a> for PyAny {
     fn lax_int(&self) -> ValResult<i64> {
         if let Ok(int) = self.extract::<i64>() {
             Ok(int)
-        } else if let Some(either_str) = maybe_as_string(self, ErrorKind::IntParsing)? {
-            str_as_int(self, &either_str.as_cow())
+        } else if let Some(cow_str) = maybe_as_string(self, ErrorKind::IntParsing)? {
+            str_as_int(self, &cow_str)
         } else if let Ok(float) = self.lax_float() {
             float_as_int(self, float)
         } else {
@@ -209,8 +210,8 @@ impl<'a> Input<'a> for PyAny {
     fn lax_float(&self) -> ValResult<f64> {
         if let Ok(float) = self.extract::<f64>() {
             Ok(float)
-        } else if let Some(either_str) = maybe_as_string(self, ErrorKind::FloatParsing)? {
-            match either_str.as_cow().as_ref().parse() {
+        } else if let Some(cow_str) = maybe_as_string(self, ErrorKind::FloatParsing)? {
+            match cow_str.as_ref().parse() {
                 Ok(i) => Ok(i),
                 Err(_) => Err(ValError::new(ErrorKind::FloatParsing, self)),
             }
@@ -515,12 +516,12 @@ fn from_attributes_applicable(obj: &PyAny) -> bool {
 }
 
 /// Utility for extracting a string from a PyAny, if possible.
-fn maybe_as_string(v: &PyAny, unicode_error: ErrorKind) -> ValResult<Option<EitherString>> {
+fn maybe_as_string(v: &PyAny, unicode_error: ErrorKind) -> ValResult<Option<Cow<str>>> {
     if let Ok(py_string) = v.cast_as::<PyString>() {
-        Ok(Some(py_string.into()))
+        Ok(Some(py_string.to_string_lossy()))
     } else if let Ok(bytes) = v.cast_as::<PyBytes>() {
         match from_utf8(bytes.as_bytes()) {
-            Ok(s) => Ok(Some(s.into())),
+            Ok(s) => Ok(Some(Cow::Owned(s.to_string()))),
             Err(_) => Err(ValError::new(unicode_error, v)),
         }
     } else {

src/input/parse_json.rs

@@ -5,18 +5,6 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use serde::de::{Deserialize, DeserializeSeed, Error as SerdeError, MapAccess, SeqAccess, Visitor};
 
-// taken from `serde_json`
-// We only use our own error type; no need for From conversions provided by the
-// standard library's try! macro. This reduces lines of LLVM IR by 4%.
-macro_rules! tri {
-    ($e:expr $(,)?) => {
-        match $e {
-            Ok(val) => val,
-            Err(err) => return Err(err),
-        }
-    };
-}
-
 /// similar to serde `Value` but with int and float split
 #[derive(Clone, Debug)]
 pub enum JsonInput {
@@ -52,7 +40,6 @@ impl ToPyObject for JsonInput {
 }
 
 impl<'de> Deserialize<'de> for JsonInput {
-    #[inline]
     fn deserialize<D>(deserializer: D) -> Result<JsonInput, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -67,65 +54,58 @@ impl<'de> Deserialize<'de> for JsonInput {
                 formatter.write_str("any valid JSON value")
             }
 
-            #[inline]
             fn visit_bool<E>(self, value: bool) -> Result<JsonInput, E> {
                 Ok(JsonInput::Bool(value))
             }
 
-            #[inline]
             fn visit_i64<E>(self, value: i64) -> Result<JsonInput, E> {
                 Ok(JsonInput::Int(value))
             }
 
-            #[inline]
             fn visit_u64<E>(self, value: u64) -> Result<JsonInput, E> {
                 Ok(JsonInput::Int(value as i64))
             }
 
-            #[inline]
             fn visit_f64<E>(self, value: f64) -> Result<JsonInput, E> {
                 Ok(JsonInput::Float(value))
             }
 
-            #[inline]
             fn visit_str<E>(self, value: &str) -> Result<JsonInput, E>
             where
                 E: SerdeError,
             {
                 Ok(JsonInput::String(value.to_string()))
             }
 
-            #[inline]
-            fn visit_string<E>(self, value: String) -> Result<JsonInput, E> {
-                Ok(JsonInput::String(value))
+            #[cfg_attr(has_no_coverage, no_coverage)]
+            fn visit_string<E>(self, _: String) -> Result<JsonInput, E> {
+                unreachable!()
             }
 
-            #[inline]
+            #[cfg_attr(has_no_coverage, no_coverage)]
             fn visit_none<E>(self) -> Result<JsonInput, E> {
-                Ok(JsonInput::Null)
+                unreachable!()
             }
 
-            #[inline]
-            fn visit_some<D>(self, deserializer: D) -> Result<JsonInput, D::Error>
+            #[cfg_attr(has_no_coverage, no_coverage)]
+            fn visit_some<D>(self, _: D) -> Result<JsonInput, D::Error>
             where
                 D: serde::Deserializer<'de>,
             {
-                Deserialize::deserialize(deserializer)
+                unreachable!()
             }
 
-            #[inline]
             fn visit_unit<E>(self) -> Result<JsonInput, E> {
                 Ok(JsonInput::Null)
             }
 
-            #[inline]
             fn visit_seq<V>(self, mut visitor: V) -> Result<JsonInput, V::Error>
             where
                 V: SeqAccess<'de>,
             {
                 let mut vec = Vec::new();
 
-                while let Some(elem) = tri!(visitor.next_element()) {
+                while let Some(elem) = visitor.next_element()? {
                     vec.push(elem);
                 }
 
@@ -140,8 +120,8 @@ impl<'de> Deserialize<'de> for JsonInput {
                     Some(first_key) => {
                         let mut values = IndexMap::new();
 
-                        values.insert(first_key, tri!(visitor.next_value()));
-                        while let Some((key, value)) = tri!(visitor.next_entry()) {
+                        values.insert(first_key, visitor.next_value()?);
+                        while let Some((key, value)) = visitor.next_entry()? {
                             values.insert(key, value);
                         }
                         Ok(JsonInput::Object(values))
@@ -183,10 +163,11 @@ impl<'de> Visitor<'de> for KeyDeserializer {
         Ok(s.to_string())
     }
 
-    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
+    #[cfg_attr(has_no_coverage, no_coverage)]
+    fn visit_string<E>(self, _: String) -> Result<Self::Value, E>
     where
         E: serde::de::Error,
     {
-        Ok(s)
+        unreachable!()
     }
 }