From 2973cad57b6e074b215daab909181378bfb97449 Mon Sep 17 00:00:00 2001
From: eater <=@eater.me>
Date: Tue, 8 Aug 2023 08:33:20 +0200
Subject: [PATCH] let containers call DecodeScalar::decode when called, instead
 of relying on default implementation

---
 src/containers.rs | 63 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 45 insertions(+), 18 deletions(-)

diff --git a/src/containers.rs b/src/containers.rs
index a09b023..c77146d 100644
--- a/src/containers.rs
+++ b/src/containers.rs
@@ -11,7 +11,7 @@ use crate::traits::{ErrorSpan, DecodeSpan, Span};
 
 impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Box<T> {
     fn decode_node(node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                   -> Result<Self, DecodeError<S>>
     {
         Decode::decode_node(node, ctx).map(Box::new)
     }
@@ -19,7 +19,7 @@ impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Box<T> {
 
 impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Box<T> {
     fn decode_children(nodes: &[SpannedNode<S>], ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                       -> Result<Self, DecodeError<S>>
     {
         DecodeChildren::decode_children(nodes, ctx).map(Box::new)
     }
@@ -27,14 +27,14 @@ impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Box<T> {
 
 impl<S: ErrorSpan, T: DecodePartial<S>> DecodePartial<S> for Box<T> {
     fn insert_child(&mut self, node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                    -> Result<bool, DecodeError<S>>
     {
         (**self).insert_child(node, ctx)
     }
     fn insert_property(&mut self,
                        name: &Spanned<Box<str>, S>, value: &Value<S>,
                        ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                       -> Result<bool, DecodeError<S>>
     {
         (**self).insert_property(name, value, ctx)
     }
@@ -46,15 +46,19 @@ impl<S: ErrorSpan, T: DecodeScalar<S>> DecodeScalar<S> for Box<T> {
         T::type_check(type_name, ctx)
     }
     fn raw_decode(value: &Spanned<Literal, S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                  -> Result<Self, DecodeError<S>>
     {
         DecodeScalar::raw_decode(value, ctx).map(Box::new)
     }
+
+    fn decode(value: &Value<S>, ctx: &mut Context<S>) -> Result<Self, DecodeError<S>> {
+        T::decode(value, ctx).map(Box::new)
+    }
 }
 
 impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Arc<T> {
     fn decode_node(node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                   -> Result<Self, DecodeError<S>>
     {
         Decode::decode_node(node, ctx).map(Arc::new)
     }
@@ -62,7 +66,7 @@ impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Arc<T> {
 
 impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Arc<T> {
     fn decode_children(nodes: &[SpannedNode<S>], ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                       -> Result<Self, DecodeError<S>>
     {
         DecodeChildren::decode_children(nodes, ctx).map(Arc::new)
     }
@@ -70,7 +74,7 @@ impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Arc<T> {
 
 impl<S: ErrorSpan, T: DecodePartial<S>> DecodePartial<S> for Arc<T> {
     fn insert_child(&mut self, node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                    -> Result<bool, DecodeError<S>>
     {
         Arc::get_mut(self).expect("no Arc clone yet")
             .insert_child(node, ctx)
@@ -78,7 +82,7 @@ impl<S: ErrorSpan, T: DecodePartial<S>> DecodePartial<S> for Arc<T> {
     fn insert_property(&mut self,
                        name: &Spanned<Box<str>, S>, value: &Value<S>,
                        ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                       -> Result<bool, DecodeError<S>>
     {
         Arc::get_mut(self).expect("no Arc clone yet")
             .insert_property(name, value, ctx)
@@ -92,15 +96,19 @@ impl<S: ErrorSpan, T: DecodeScalar<S>> DecodeScalar<S> for Arc<T> {
         T::type_check(type_name, ctx)
     }
     fn raw_decode(value: &Spanned<Literal, S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                  -> Result<Self, DecodeError<S>>
     {
         DecodeScalar::raw_decode(value, ctx).map(Arc::new)
     }
+
+    fn decode(value: &Value<S>, ctx: &mut Context<S>) -> Result<Self, DecodeError<S>> {
+        T::decode(value, ctx).map(Arc::new)
+    }
 }
 
 impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Rc<T> {
     fn decode_node(node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                   -> Result<Self, DecodeError<S>>
     {
         Decode::decode_node(node, ctx).map(Rc::new)
     }
@@ -108,7 +116,7 @@ impl<S: ErrorSpan, T: Decode<S>> Decode<S> for Rc<T> {
 
 impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Rc<T> {
     fn decode_children(nodes: &[SpannedNode<S>], ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                       -> Result<Self, DecodeError<S>>
     {
         DecodeChildren::decode_children(nodes, ctx).map(Rc::new)
     }
@@ -116,7 +124,7 @@ impl<S: ErrorSpan, T: DecodeChildren<S>> DecodeChildren<S> for Rc<T> {
 
 impl<S: ErrorSpan, T: DecodePartial<S>> DecodePartial<S> for Rc<T> {
     fn insert_child(&mut self, node: &SpannedNode<S>, ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                    -> Result<bool, DecodeError<S>>
     {
         Rc::get_mut(self).expect("no Rc clone yet")
             .insert_child(node, ctx)
@@ -124,7 +132,7 @@ impl<S: ErrorSpan, T: DecodePartial<S>> DecodePartial<S> for Rc<T> {
     fn insert_property(&mut self,
                        name: &Spanned<Box<str>, S>, value: &Value<S>,
                        ctx: &mut Context<S>)
-        -> Result<bool, DecodeError<S>>
+                       -> Result<bool, DecodeError<S>>
     {
         Rc::get_mut(self).expect("no Rc clone yet")
             .insert_property(name, value, ctx)
@@ -138,15 +146,19 @@ impl<S: ErrorSpan, T: DecodeScalar<S>> DecodeScalar<S> for Rc<T> {
         T::type_check(type_name, ctx)
     }
     fn raw_decode(value: &Spanned<Literal, S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                  -> Result<Self, DecodeError<S>>
     {
         DecodeScalar::raw_decode(value, ctx).map(Rc::new)
     }
+
+    fn decode(value: &Value<S>, ctx: &mut Context<S>) -> Result<Self, DecodeError<S>> {
+        T::decode(value, ctx).map(Rc::new)
+    }
 }
 
 impl<S: ErrorSpan, T: Decode<S>> DecodeChildren<S> for Vec<T> {
     fn decode_children(nodes: &[SpannedNode<S>], ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                       -> Result<Self, DecodeError<S>>
     {
         let mut result = Vec::with_capacity(nodes.len());
         for node in nodes {
@@ -165,13 +177,20 @@ impl<S: ErrorSpan, T: DecodeScalar<S>> DecodeScalar<S> for Option<T> {
         T::type_check(type_name, ctx)
     }
     fn raw_decode(value: &Spanned<Literal, S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                  -> Result<Self, DecodeError<S>>
     {
         match &**value {
             Literal::Null => Ok(None),
             _ => DecodeScalar::raw_decode(value, ctx).map(Some),
         }
     }
+
+    fn decode(value: &Value<S>, ctx: &mut Context<S>) -> Result<Self, DecodeError<S>> {
+        match &*value.literal {
+            Literal::Null => Ok(None),
+            _ => T::decode(value, ctx).map(Some)
+        }
+    }
 }
 
 impl<T: DecodeScalar<S>, S, Q> DecodeScalar<S> for Spanned<T, Q>
@@ -184,7 +203,7 @@ impl<T: DecodeScalar<S>, S, Q> DecodeScalar<S> for Spanned<T, Q>
         T::type_check(type_name, ctx)
     }
     fn raw_decode(value: &Spanned<Literal, S>, ctx: &mut Context<S>)
-        -> Result<Self, DecodeError<S>>
+                  -> Result<Self, DecodeError<S>>
     {
         let decoded = T::raw_decode(value, ctx)?;
         Ok(Spanned {
@@ -192,4 +211,12 @@ impl<T: DecodeScalar<S>, S, Q> DecodeScalar<S> for Spanned<T, Q>
             value: decoded,
         })
     }
+
+    fn decode(value: &Value<S>, ctx: &mut Context<S>) -> Result<Self, DecodeError<S>> {
+        let decoded = T::decode(value, ctx)?;
+        Ok(Spanned {
+            span: DecodeSpan::decode_span(&value.literal.span, ctx),
+            value: decoded,
+        })
+    }
 }