Change Ty::Tuple to Ty::Unit.

Because that's all that is needed in practice.

compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

@@ -33,7 +33,7 @@ pub fn expand_deriving_eq(
             generics: Bounds::empty(),
             explicit_self: true,
             args: vec![],
-            ret_ty: nil_ty(),
+            ret_ty: Unit,
             attributes: attrs,
             unify_fieldless_variants: true,
             combine_substructure: combine_substructure(Box::new(|a, b, c| {

compiler/rustc_builtin_macros/src/deriving/encodable.rs

@@ -125,7 +125,7 @@ pub fn expand_deriving_rustc_encodable(
             ret_ty: Path(Path::new_(
                 pathvec_std!(result::Result),
                 vec![
-                    Box::new(Tuple(Vec::new())),
+                    Box::new(Unit),
                     Box::new(Path(Path::new_(vec![typaram, sym::Error], vec![], PathKind::Local))),
                 ],
                 PathKind::Std,

compiler/rustc_builtin_macros/src/deriving/generic/ty.rs

@@ -78,18 +78,14 @@ pub enum Ty {
     /// `mod::mod::Type<[lifetime], [Params...]>`, including a plain type
     /// parameter, and things like `i32`
     Path(Path),
-    /// includes unit
-    Tuple(Vec<Ty>),
+    /// For () return types.
+    Unit,
 }
 
 pub fn self_ref() -> Ty {
     Ref(Box::new(Self_), ast::Mutability::Not)
 }
 
-pub fn nil_ty() -> Ty {
-    Tuple(Vec::new())
-}
-
 impl Ty {
     pub fn to_ty(
         &self,
@@ -105,10 +101,8 @@ impl Ty {
             }
             Path(p) => p.to_ty(cx, span, self_ty, self_generics),
             Self_ => cx.ty_path(self.to_path(cx, span, self_ty, self_generics)),
-            Tuple(fields) => {
-                let ty = ast::TyKind::Tup(
-                    fields.iter().map(|f| f.to_ty(cx, span, self_ty, self_generics)).collect(),
-                );
+            Unit => {
+                let ty = ast::TyKind::Tup(vec![]);
                 cx.ty(span, ty)
             }
         }
@@ -143,7 +137,7 @@ impl Ty {
             }
             Path(ref p) => p.to_path(cx, span, self_ty, generics),
             Ref(..) => cx.span_bug(span, "ref in a path in generic `derive`"),
-            Tuple(..) => cx.span_bug(span, "tuple in a path in generic `derive`"),
+            Unit => cx.span_bug(span, "unit in a path in generic `derive`"),
         }
     }
 }

compiler/rustc_builtin_macros/src/deriving/hash.rs

@@ -32,7 +32,7 @@ pub fn expand_deriving_hash(
             generics: Bounds { bounds: vec![(typaram, vec![path_std!(hash::Hasher)])] },
             explicit_self: true,
             args: vec![(Ref(Box::new(Path(arg)), Mutability::Mut), sym::state)],
-            ret_ty: nil_ty(),
+            ret_ty: Unit,
             attributes: vec![],
             unify_fieldless_variants: true,
             combine_substructure: combine_substructure(Box::new(|a, b, c| {