Evaluate error lazily

tyranron · tyranron · commit 2dc7d13c7d30 · 2025-06-17T21:03:58.000+02:00
diff --git a/juniper/src/ast.rs b/juniper/src/ast.rs
@@ -609,13 +609,13 @@ impl<'a, S> VariableDefinitions<'a, S> {
 }
 
 #[cfg(test)]
-mod tests {
+mod spec_input_value_fmt {
     use crate::graphql_input_value;
 
     use super::InputValue;
 
     #[test]
-    fn test_input_value_fmt() {
+    fn correct() {
         let value: InputValue = graphql_input_value!(null);
         assert_eq!(value.to_string(), "null");
 
diff --git a/juniper/src/integrations/bigdecimal.rs b/juniper/src/integrations/bigdecimal.rs
@@ -54,7 +54,7 @@ mod bigdecimal_scalar {
                 .map_err(|e| format!("Failed to parse `BigDecimal` from `Float`: {e}").into())
         } else {
             v.try_to::<&str>()
-                .map_err(|e| e.message().into())
+                .map_err(|e| e.to_string().into())
                 .and_then(|s| {
                     BigDecimal::from_str(s).map_err(|e| {
                         format!("Failed to parse `BigDecimal` from `String`: {e}").into()
diff --git a/juniper/src/integrations/rust_decimal.rs b/juniper/src/integrations/rust_decimal.rs
@@ -48,7 +48,7 @@ mod rust_decimal_scalar {
                 .map_err(|e| format!("Failed to parse `Decimal` from `Float`: {e}").into())
         } else {
             v.try_to::<&str>()
-                .map_err(|e| e.message().into())
+                .map_err(|e| e.to_string().into())
                 .and_then(|s| {
                     Decimal::from_str(s)
                         .map_err(|e| format!("Failed to parse `Decimal` from `String`: {e}").into())
diff --git a/juniper/src/types/pointers.rs b/juniper/src/types/pointers.rs
@@ -3,7 +3,7 @@ use std::{fmt, sync::Arc};
 use arcstr::ArcStr;
 
 use crate::{
-    BoxFuture, FieldResult,
+    BoxFuture,
     ast::{FromInputValue, InputValue, Selection, ToInputValue},
     executor::{ExecutionResult, Executor, Registry},
     schema::meta::MetaType,
@@ -92,7 +92,9 @@ where
     S: ScalarValue,
     T: FromScalarValue<'s, S> + 's,
 {
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+    type Error = T::Error;
+
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
         T::from_scalar_value(v).map(Self::new)
     }
 }
@@ -290,7 +292,9 @@ where
     S: ScalarValue,
     T: FromScalarValue<'s, S> + 's,
 {
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+    type Error = T::Error;
+
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
         T::from_scalar_value(v).map(Self::new)
     }
 }
diff --git a/juniper/src/types/scalars.rs b/juniper/src/types/scalars.rs
@@ -69,9 +69,10 @@ mod impl_string_scalar {
     where
         S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
     {
-        fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        type Error = S::Error;
+
+        fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
             v.try_scalar_value_to()
-                .map_err(IntoFieldError::into_field_error)
         }
     }
 
@@ -189,13 +190,15 @@ type ArcStr = arcstr::ArcStr;
 
 mod impl_arcstr_scalar {
     use super::ArcStr;
-    use crate::{FieldResult, IntoValue as _, Scalar, ScalarValue, Value};
+    use crate::{FromScalarValue, IntoValue as _, Scalar, ScalarValue, Value};
 
     pub(super) fn to_output<S: ScalarValue>(v: &ArcStr) -> Value<S> {
         v.into_value()
     }
 
-    pub(super) fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<ArcStr, S> {
+    pub(super) fn from_input<S: ScalarValue>(
+        v: &Scalar<S>,
+    ) -> Result<ArcStr, <&str as FromScalarValue<S>>::Error> {
         if let Some(s) = v.downcast_type::<ArcStr>() {
             Ok(s.clone())
         } else {
@@ -210,13 +213,15 @@ type CompactString = compact_str::CompactString;
 
 mod impl_compactstring_scalar {
     use super::CompactString;
-    use crate::{FieldResult, IntoValue as _, Scalar, ScalarValue, Value};
+    use crate::{FromScalarValue, IntoValue as _, Scalar, ScalarValue, Value};
 
     pub(super) fn to_output<S: ScalarValue>(v: &CompactString) -> Value<S> {
         v.into_value()
     }
 
-    pub(super) fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<CompactString, S> {
+    pub(super) fn from_input<S: ScalarValue>(
+        v: &Scalar<S>,
+    ) -> Result<CompactString, <&str as FromScalarValue<S>>::Error> {
         if let Some(s) = v.downcast_type::<CompactString>() {
             Ok(s.clone())
         } else {
@@ -299,9 +304,10 @@ impl<'s, S> FromScalarValue<'s, S> for &'s str
 where
     S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
 {
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+    type Error = S::Error;
+
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
         v.try_scalar_value_to()
-            .map_err(IntoFieldError::into_field_error)
     }
 }
 
@@ -316,9 +322,10 @@ mod impl_boolean_scalar {
     where
         S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
     {
-        fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        type Error = S::Error;
+
+        fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
             v.try_scalar_value_to()
-                .map_err(IntoFieldError::into_field_error)
         }
     }
 
@@ -343,9 +350,10 @@ mod impl_int_scalar {
     where
         S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
     {
-        fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        type Error = S::Error;
+
+        fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
             v.try_scalar_value_to()
-                .map_err(IntoFieldError::into_field_error)
         }
     }
 
@@ -375,9 +383,10 @@ mod impl_float_scalar {
     where
         S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
     {
-        fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        type Error = S::Error;
+
+        fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
             v.try_scalar_value_to()
-                .map_err(IntoFieldError::into_field_error)
         }
     }
 
diff --git a/juniper/src/value/scalar.rs b/juniper/src/value/scalar.rs
@@ -194,7 +194,6 @@ pub trait ScalarValue:
     + for<'a> TryScalarValueTo<'a, f64, Error: Display + IntoFieldError<Self>>
     + for<'a> TryScalarValueTo<'a, String, Error: Display + IntoFieldError<Self>>
     + for<'a> TryScalarValueTo<'a, &'a str, Error: Display + IntoFieldError<Self>>
-    + for<'a> TryScalarValueTo<'a, &'a Self, Error: Display + IntoFieldError<Self>>
     + TryInto<String>
     + 'static
 {
@@ -248,14 +247,16 @@ pub trait ScalarValue:
     ///
     /// ```rust
     /// # use arcstr::ArcStr;
-    /// # use juniper::{FieldResult, GraphQLScalar, Scalar, ScalarValue, TryScalarValueTo, Value};
+    /// # use juniper::{FromScalarValue, GraphQLScalar, Scalar, ScalarValue, TryScalarValueTo, Value};
     /// #
     /// #[derive(GraphQLScalar)]
     /// #[graphql(from_input_with = Self::from_input, transparent)]
     /// struct Name(ArcStr);
     ///
     /// impl Name {
-    ///     fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<Self, S> {
+    ///     fn from_input<S: ScalarValue>(
+    ///         v: &Scalar<S>,
+    ///     ) -> Result<Self, <&str as FromScalarValue<S>>::Error> {
     ///         // Check if our `ScalarValue` is represented by an `ArcStr` already, and if so,
     ///         // do the cheap `Clone` instead of allocating a new `ArcStr` in its `From<&str>`
     ///         // implementation.
@@ -282,7 +283,7 @@ pub trait ScalarValue:
     ///
     /// Implementations should not implement this method, but rather implement the
     /// [`TryScalarValueTo<T>`] conversion directly.
-    fn try_to<'a, T>(&'a self) -> FieldResult<T, Self>
+    fn try_to<'a, T>(&'a self) -> Result<T, T::Error>
     where
         T: FromScalarValue<'a, Self> + 'a,
     {
@@ -303,7 +304,7 @@ pub trait ScalarValue:
     /// [`TryScalarValueTo<bool>`] conversions for all the supported boolean types.
     #[must_use]
     fn try_to_bool(&self) -> Option<bool> {
-        self.try_scalar_value_to().ok()
+        self.try_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as an [`i32`] value.
@@ -321,7 +322,7 @@ pub trait ScalarValue:
     /// less to an integer, if requested.
     #[must_use]
     fn try_to_int(&self) -> Option<i32> {
-        self.try_scalar_value_to().ok()
+        self.try_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as a [`f64`] value.
@@ -339,7 +340,7 @@ pub trait ScalarValue:
     /// all floating point values with 64 bit or less to a float, if requested.
     #[must_use]
     fn try_to_float(&self) -> Option<f64> {
-        self.try_scalar_value_to().ok()
+        self.try_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as a [`String`] value.
@@ -359,7 +360,7 @@ pub trait ScalarValue:
     /// [`TryScalarValueTo<String>`] conversions for all the supported string types, if requested.
     #[must_use]
     fn try_to_string(&self) -> Option<String> {
-        self.try_scalar_value_to().ok()
+        self.try_to().ok()
     }
 
     /// Tries to convert this [`ScalarValue`] into a [`String`] value.
@@ -396,7 +397,7 @@ pub trait ScalarValue:
     /// requested.
     #[must_use]
     fn try_as_str(&self) -> Option<&str> {
-        self.try_scalar_value_to().ok()
+        self.try_to().ok()
     }
 
     /// Converts this [`ScalarValue`] into another one via [`i32`], [`f64`], [`bool`] or [`String`]
@@ -449,7 +450,7 @@ pub trait ScalarValue:
 /// all the required primitive types if `#[to_<type>]` and `#[as_<type>]` attributes are specified.
 pub trait TryScalarValueTo<'me, T: 'me> {
     /// Error if this [`ScalarValue`] doesn't represent the expected type.
-    type Error;
+    type Error: 'me;
 
     /// Tries to represent this [`ScalarValue`] as the expected type.
     ///
@@ -459,47 +460,25 @@ pub trait TryScalarValueTo<'me, T: 'me> {
     fn try_scalar_value_to(&'me self) -> Result<T, Self::Error>;
 }
 
-impl<'me, S: ScalarValue> TryScalarValueTo<'me, &'me S> for S {
-    type Error = Infallible;
-
-    fn try_scalar_value_to(&'me self) -> Result<&'me S, Self::Error> {
-        Ok(self)
-    }
-}
-
-impl<'me, S: ScalarValue> TryScalarValueTo<'me, &'me Scalar<S>> for S {
-    type Error = Infallible;
-
-    fn try_scalar_value_to(&'me self) -> Result<&'me Scalar<S>, Self::Error> {
-        Ok(Scalar::ref_cast(self))
-    }
-}
-
-impl<'me, T, S> TryScalarValueTo<'me, Scalar<T>> for S
-where
-    T: FromScalarValue<'me, S> + 'me,
-    S: ScalarValue,
-{
-    type Error = FieldError<Self>;
-
-    fn try_scalar_value_to(&'me self) -> FieldResult<Scalar<T>, Self> {
-        T::from_scalar_value(self).map(Scalar)
-    }
-}
-
 pub trait FromScalarValue<'s, S: 's = DefaultScalarValue>: Sized {
+    type Error: IntoFieldError<S> + 's;
+
     /// Performs the conversion.
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S>;
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error>;
 }
 
 impl<'s, S> FromScalarValue<'s, S> for &'s S {
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+    type Error = Infallible;
+
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
         Ok(v)
     }
 }
 
-impl<'s, S> FromScalarValue<'s, S> for &'s Scalar<S> {
-    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+impl<'s, S: ScalarValue> FromScalarValue<'s, S> for &'s Scalar<S> {
+    type Error = Infallible;
+
+    fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {
         Ok(Scalar::ref_cast(v))
     }
 }
@@ -541,9 +520,8 @@ impl<'a, S: ScalarValue> Display for ScalarValueFmt<'a, S> {
 /// expansions.
 #[derive(Debug, Deref, Display, RefCast)]
 #[display("{}", ScalarValueFmt(_0))]
-#[display(bound(T: ScalarValue))]
 #[repr(transparent)]
-pub struct Scalar<T>(T);
+pub struct Scalar<T: ScalarValue>(T);
 
 /// Extension of [`Any`] for using its methods directly on the value without `dyn`.
 pub trait AnyExt: Any {
diff --git a/juniper_codegen/src/graphql_scalar/mod.rs b/juniper_codegen/src/graphql_scalar/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use std::{fmt, sync::Arc};`
`3`	`3`	`use arcstr::ArcStr;`
`4`	`4`
`5`	`5`	`use crate::{`
`6`		`- BoxFuture, FieldResult,`
	`6`	`+ BoxFuture,`
`7`	`7`	`ast::{FromInputValue, InputValue, Selection, ToInputValue},`
`8`	`8`	`executor::{ExecutionResult, Executor, Registry},`
`9`	`9`	`schema::meta::MetaType,`
`@@ -92,7 +92,9 @@ where`
`92`	`92`	`S: ScalarValue,`
`93`	`93`	`T: FromScalarValue<'s, S> + 's,`
`94`	`94`	`{`
`95`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`95`	`+ type Error = T::Error;`
	`96`	`+`
	`97`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`96`	`98`	`T::from_scalar_value(v).map(Self::new)`
`97`	`99`	`}`
`98`	`100`	`}`
`@@ -290,7 +292,9 @@ where`
`290`	`292`	`S: ScalarValue,`
`291`	`293`	`T: FromScalarValue<'s, S> + 's,`
`292`	`294`	`{`
`293`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`295`	`+ type Error = T::Error;`
	`296`	`+`
	`297`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`294`	`298`	`T::from_scalar_value(v).map(Self::new)`
`295`	`299`	`}`
`296`	`300`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,9 +69,10 @@ mod impl_string_scalar {`
`69`	`69`	`where`
`70`	`70`	`S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,`
`71`	`71`	`{`
`72`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`72`	`+ type Error = S::Error;`
	`73`	`+`
	`74`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`73`	`75`	`v.try_scalar_value_to()`
`74`		`- .map_err(IntoFieldError::into_field_error)`
`75`	`76`	`}`
`76`	`77`	`}`
`77`	`78`
`@@ -189,13 +190,15 @@ type ArcStr = arcstr::ArcStr;`
`189`	`190`
`190`	`191`	`mod impl_arcstr_scalar {`
`191`	`192`	`use super::ArcStr;`
`192`		`- use crate::{FieldResult, IntoValue as _, Scalar, ScalarValue, Value};`
	`193`	`+ use crate::{FromScalarValue, IntoValue as _, Scalar, ScalarValue, Value};`
`193`	`194`
`194`	`195`	`pub(super) fn to_output<S: ScalarValue>(v: &ArcStr) -> Value<S> {`
`195`	`196`	`v.into_value()`
`196`	`197`	`}`
`197`	`198`
`198`		`- pub(super) fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<ArcStr, S> {`
	`199`	`+ pub(super) fn from_input<S: ScalarValue>(`
	`200`	`+ v: &Scalar<S>,`
	`201`	`+ ) -> Result<ArcStr, <&str as FromScalarValue<S>>::Error> {`
`199`	`202`	`if let Some(s) = v.downcast_type::<ArcStr>() {`
`200`	`203`	`Ok(s.clone())`
`201`	`204`	`} else {`
`@@ -210,13 +213,15 @@ type CompactString = compact_str::CompactString;`
`210`	`213`
`211`	`214`	`mod impl_compactstring_scalar {`
`212`	`215`	`use super::CompactString;`
`213`		`- use crate::{FieldResult, IntoValue as _, Scalar, ScalarValue, Value};`
	`216`	`+ use crate::{FromScalarValue, IntoValue as _, Scalar, ScalarValue, Value};`
`214`	`217`
`215`	`218`	`pub(super) fn to_output<S: ScalarValue>(v: &CompactString) -> Value<S> {`
`216`	`219`	`v.into_value()`
`217`	`220`	`}`
`218`	`221`
`219`		`- pub(super) fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<CompactString, S> {`
	`222`	`+ pub(super) fn from_input<S: ScalarValue>(`
	`223`	`+ v: &Scalar<S>,`
	`224`	`+ ) -> Result<CompactString, <&str as FromScalarValue<S>>::Error> {`
`220`	`225`	`if let Some(s) = v.downcast_type::<CompactString>() {`
`221`	`226`	`Ok(s.clone())`
`222`	`227`	`} else {`
`@@ -299,9 +304,10 @@ impl<'s, S> FromScalarValue<'s, S> for &'s str`
`299`	`304`	`where`
`300`	`305`	`S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,`
`301`	`306`	`{`
`302`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`307`	`+ type Error = S::Error;`
	`308`	`+`
	`309`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`303`	`310`	`v.try_scalar_value_to()`
`304`		`- .map_err(IntoFieldError::into_field_error)`
`305`	`311`	`}`
`306`	`312`	`}`
`307`	`313`
`@@ -316,9 +322,10 @@ mod impl_boolean_scalar {`
`316`	`322`	`where`
`317`	`323`	`S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,`
`318`	`324`	`{`
`319`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`325`	`+ type Error = S::Error;`
	`326`	`+`
	`327`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`320`	`328`	`v.try_scalar_value_to()`
`321`		`- .map_err(IntoFieldError::into_field_error)`
`322`	`329`	`}`
`323`	`330`	`}`
`324`	`331`
`@@ -343,9 +350,10 @@ mod impl_int_scalar {`
`343`	`350`	`where`
`344`	`351`	`S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,`
`345`	`352`	`{`
`346`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`353`	`+ type Error = S::Error;`
	`354`	`+`
	`355`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`347`	`356`	`v.try_scalar_value_to()`
`348`		`- .map_err(IntoFieldError::into_field_error)`
`349`	`357`	`}`
`350`	`358`	`}`
`351`	`359`
`@@ -375,9 +383,10 @@ mod impl_float_scalar {`
`375`	`383`	`where`
`376`	`384`	`S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,`
`377`	`385`	`{`
`378`		`- fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {`
	`386`	`+ type Error = S::Error;`
	`387`	`+`
	`388`	`+ fn from_scalar_value(v: &'s S) -> Result<Self, Self::Error> {`
`379`	`389`	`v.try_scalar_value_to()`
`380`		`- .map_err(IntoFieldError::into_field_error)`
`381`	`390`	`}`
`382`	`391`	`}`
`383`	`392`