More cleanup

serde_macros/src/lib.rs

@@ -763,31 +763,10 @@ fn deserialize_struct_unnamed_fields(
     );
 
     // Build `__Visitor<A, B, ...>(PhantomData<A>, PhantomData<B>, ...)`
-    let (visitor_struct, visitor_expr) = if generics.ty_params.is_empty() {
+    let (visitor_struct, visitor_expr) = deserialize_struct_unnamed_field_visitor(
-        (
+        builder,
-            builder.item().tuple_struct("__Visitor")
+        generics
-                .build(),
+    );
-            builder.expr().id("__Visitor"),
-        )
-    } else {
-        (
-            builder.item().tuple_struct("__Visitor")
-                .generics().with(generics.clone()).build()
-                .with_tys(
-                    generics.ty_params.iter().map(|ty_param| {
-                        builder.ty().phantom_data().id(ty_param.ident)
-                    })
-                )
-                .build(),
-            builder.expr().call().id("__Visitor")
-                .with_args(
-                    generics.ty_params.iter().map(|_| {
-                        builder.expr().phantom_data()
-                    })
-                )
-                .build(),
-        )
-    };
 
     let struct_name = builder.expr().str(struct_ident);
 
@@ -796,7 +775,7 @@ fn deserialize_struct_unnamed_fields(
         .build();
 
     quote_expr!(cx, {
-        $visitor_struct;
+        $visitor_struct
 
         impl $trait_generics ::serde::de::Visitor for __Visitor $type_generics $where_clause {
             type Value = $value_ty;
@@ -1183,7 +1162,7 @@ fn deserialize_enum(
     enum_def: &EnumDef,
     generics: &ast::Generics,
 ) -> P<ast::Expr> {
-    let visitor_impl_generics = builder.from_generics(generics.clone())
+    let trait_generics = builder.from_generics(generics.clone())
         .add_ty_param_bound(
             builder.path().global().ids(&["serde", "de", "Deserialize"]).build()
         )
@@ -1239,10 +1218,8 @@ fn deserialize_enum(
                 fields,
                 cx.expr_ident(span, cx.ident_of("visitor")),
                 variant_ptr,
-                &visitor_impl_generics,
-                &visitor_ty,
-                &visitor_expr,
                 &value_ty,
+                generics,
             );
 
             let s = builder.expr().str(name);
@@ -1253,7 +1230,7 @@ fn deserialize_enum(
     quote_expr!(cx, {
         $visitor_struct;
 
-        impl $visitor_impl_generics ::serde::de::Visitor for $visitor_ty {
+        impl $trait_generics ::serde::de::Visitor for $visitor_ty {
             type Value = $value_ty;
 
             fn visit_enum<__V>(&mut self,
@@ -1285,6 +1262,37 @@ fn deserialize_enum(
     })
 }
 
+fn deserialize_struct_unnamed_field_visitor(
+    builder: &aster::AstBuilder,
+    generics: &ast::Generics,
+) -> (P<ast::Item>, P<ast::Expr>) {
+    if generics.ty_params.is_empty() {
+        (
+            builder.item().tuple_struct("__Visitor")
+                .build(),
+            builder.expr().id("__Visitor"),
+        )
+    } else {
+        (
+            builder.item().tuple_struct("__Visitor")
+                .generics().with(generics.clone()).build()
+                .with_tys(
+                    generics.ty_params.iter().map(|ty_param| {
+                        builder.ty().phantom_data().id(ty_param.ident)
+                    })
+                )
+                .build(),
+            builder.expr().call().id("__Visitor")
+                .with_args(
+                    generics.ty_params.iter().map(|_| {
+                        builder.expr().phantom_data()
+                    })
+                )
+                .build(),
+        )
+    }
+}
+
 fn deserialize_enum_variant(
     cx: &ExtCtxt,
     span: Span,
@@ -1294,23 +1302,69 @@ fn deserialize_enum_variant(
     fields: &StaticFields,
     state: P<ast::Expr>,
     variant_ptr: &P<ast::Variant>,
-    visitor_impl_generics: &ast::Generics,
-    visitor_ty: &P<ast::Ty>,
-    visitor_expr: &P<ast::Expr>,
     value_ty: &P<ast::Ty>,
+    generics: &ast::Generics,
 ) -> P<ast::Expr> {
     let variant_path = cx.path(span, vec![type_ident, variant_ident]);
 
     match *fields {
-        Unnamed(ref fields) => {
+        Unnamed(ref fields) if fields.is_empty() => {
-            if fields.is_empty() {
             let result = cx.expr_path(variant_path);
 
             quote_expr!(cx, {
                 try!($state.visit_unit());
                 Ok($result)
             })
-            } else {
+        }
+
+        Unnamed(ref fields) => {
+            deserialize_enum_variant_seq(
+                cx,
+                builder,
+                &*fields,
+                variant_path,
+                generics,
+                state,
+                value_ty,
+            )
+        }
+        Named(ref fields) => {
+            deserialize_enum_variant_map(
+                cx,
+                span,
+                builder,
+                &*fields,
+                variant_path,
+                generics,
+                state,
+                value_ty,
+                variant_ptr,
+            )
+        }
+    }
+}
+
+fn deserialize_enum_variant_seq(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    fields: &[Span],
+    variant_path: ast::Path,
+    generics: &ast::Generics,
+    state: P<ast::Expr>,
+    value_ty: &P<ast::Ty>,
+) -> P<ast::Expr> {
+    let trait_generics = builder.from_generics(generics.clone())
+        .add_ty_param_bound(
+            builder.path().global().ids(&["serde", "de", "Deserialize"]).build()
+        )
+        .build();
+
+    let where_clause = &trait_generics.where_clause;
+
+    let type_generics = builder.from_generics(trait_generics.clone())
+        .strip_bounds()
+        .build();
+
     // Create the field names for the fields.
     let field_names: Vec<ast::Ident> = (0 .. fields.len())
         .map(|i| token::str_to_ident(&format!("__field{}", i)))
@@ -1323,8 +1377,15 @@ fn deserialize_enum_variant(
         &field_names,
     );
 
+    let (visitor_struct, visitor_expr) = deserialize_struct_unnamed_field_visitor(
+        builder,
+        generics
+    );
+
     quote_expr!(cx, {
-                    impl $visitor_impl_generics ::serde::de::EnumSeqVisitor for $visitor_ty {
+        $visitor_struct
+
+        impl $trait_generics ::serde::de::EnumSeqVisitor for __Visitor $type_generics $where_clause {
             type Value = $value_ty;
 
             fn visit<
@@ -1336,9 +1397,32 @@ fn deserialize_enum_variant(
 
         $state.visit_seq($visitor_expr)
     })
-            }
+}
-        }
+
-        Named(ref fields) => {
+
+fn deserialize_enum_variant_map(
+    cx: &ExtCtxt,
+    span: Span,
+    builder: &aster::AstBuilder,
+    fields: &[(Ident, Span)],
+    variant_path: ast::Path,
+    generics: &ast::Generics,
+    state: P<ast::Expr>,
+    value_ty: &P<ast::Ty>,
+    variant_ptr: &P<ast::Variant>,
+) -> P<ast::Expr> {
+    let trait_generics = builder.from_generics(generics.clone())
+        .add_ty_param_bound(
+            builder.path().global().ids(&["serde", "de", "Deserialize"]).build()
+        )
+        .build();
+
+    let where_clause = &trait_generics.where_clause;
+
+    let type_generics = builder.from_generics(trait_generics.clone())
+        .strip_bounds()
+        .build();
+
     // Create the field names for the fields.
     let field_names: Vec<ast::Ident> = (0 .. fields.len())
         .map(|i| token::str_to_ident(&format!("__field{}", i)))
@@ -1368,10 +1452,16 @@ fn deserialize_enum_variant(
         },
     );
 
+    let (visitor_struct, visitor_expr) = deserialize_struct_unnamed_field_visitor(
+        builder,
+        generics
+    );
+
     quote_expr!(cx, {
+        $visitor_struct
         $field_devisitor
 
-                impl $visitor_impl_generics ::serde::de::EnumMapVisitor for $visitor_ty {
+        impl $trait_generics ::serde::de::EnumMapVisitor for __Visitor $type_generics $where_clause {
             type Value = $value_ty;
 
             fn visit<
@@ -1383,6 +1473,4 @@ fn deserialize_enum_variant(
 
         $state.visit_map($visitor_expr)
     })
-        }
-    }
 }