diff --git a/src/expr.rs b/src/expr.rs
index 97db379..f717b2b 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -70,7 +70,7 @@
         }),
 
         /// A tuple, e.g. `(a, b, c, d)`.
-        pub Tup(ExprTup #full {
+        pub Tuple(ExprTuple #full {
             pub args: Delimited<Expr, Token![,]>,
             pub paren_token: tokens::Paren,
             pub lone_comma: Option<Token![,]>,
@@ -1154,7 +1154,7 @@
         |
         syn!(ExprArray) => { ExprKind::Array }
         |
-        syn!(ExprTup) => { ExprKind::Tup }
+        syn!(ExprTuple) => { ExprKind::Tuple }
         |
         syn!(ExprIf) => { ExprKind::If }
         |
@@ -1320,10 +1320,10 @@
     ));
 
     #[cfg(feature = "full")]
-    impl Synom for ExprTup {
+    impl Synom for ExprTuple {
         named!(parse -> Self, do_parse!(
             elems: parens!(call!(Delimited::parse_terminated)) >>
-            (ExprTup {
+            (ExprTuple {
                 args: elems.0,
                 paren_token: elems.1,
                 lone_comma: None, // TODO: parse this
@@ -2354,12 +2354,12 @@
     }
 
     #[cfg(feature = "full")]
-    impl ToTokens for ExprTup {
+    impl ToTokens for ExprTuple {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.paren_token.surround(tokens, |tokens| {
                 self.args.to_tokens(tokens);
                 // If we only have one argument, we need a trailing comma to
-                // distinguish ExprTup from ExprParen.
+                // distinguish ExprTuple from ExprParen.
                 if self.args.len() == 1 && !self.args.trailing_delim() {
                     <Token![,]>::default().to_tokens(tokens);
                 }
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index a7c5f9e..adc3c65 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -170,9 +170,9 @@
 # [ cfg ( feature = "full" ) ]
 fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { fold_expr_try(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_tup(&mut self, i: ExprTup) -> ExprTup { fold_expr_tup(self, i) }
-# [ cfg ( feature = "full" ) ]
 fn fold_expr_tup_field(&mut self, i: ExprTupField) -> ExprTupField { fold_expr_tup_field(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple { fold_expr_tuple(self, i) }
 
 fn fold_expr_type(&mut self, i: ExprType) -> ExprType { fold_expr_type(self, i) }
 
@@ -372,7 +372,7 @@
 
 fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject { fold_type_trait_object(self, i) }
 
-fn fold_type_tup(&mut self, i: TypeTup) -> TypeTup { fold_type_tup(self, i) }
+fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple { fold_type_tuple(self, i) }
 
 fn fold_un_op(&mut self, i: UnOp) -> UnOp { fold_un_op(self, i) }
 
@@ -1007,9 +1007,9 @@
                 full!(_visitor.fold_expr_method_call(_binding_0)),
             )
         }
-        Tup(_binding_0, ) => {
-            Tup (
-                full!(_visitor.fold_expr_tup(_binding_0)),
+        Tuple(_binding_0, ) => {
+            Tuple (
+                full!(_visitor.fold_expr_tuple(_binding_0)),
             )
         }
         Binary(_binding_0, ) => {
@@ -1272,14 +1272,6 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn fold_expr_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTup) -> ExprTup {
-    ExprTup {
-        args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
-        paren_token: _i . paren_token,
-        lone_comma: _i . lone_comma,
-    }
-}
-# [ cfg ( feature = "full" ) ]
 pub fn fold_expr_tup_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTupField) -> ExprTupField {
     ExprTupField {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
@@ -1287,6 +1279,14 @@
         dot_token: _i . dot_token,
     }
 }
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple {
+    ExprTuple {
+        args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
+        paren_token: _i . paren_token,
+        lone_comma: _i . lone_comma,
+    }
+}
 
 pub fn fold_expr_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType {
     ExprType {
@@ -2423,9 +2423,9 @@
                 _visitor.fold_type_never(_binding_0),
             )
         }
-        Tup(_binding_0, ) => {
-            Tup (
-                _visitor.fold_type_tup(_binding_0),
+        Tuple(_binding_0, ) => {
+            Tuple (
+                _visitor.fold_type_tuple(_binding_0),
             )
         }
         Path(_binding_0, ) => {
@@ -2587,8 +2587,8 @@
     }
 }
 
-pub fn fold_type_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeTup) -> TypeTup {
-    TypeTup {
+pub fn fold_type_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeTuple) -> TypeTuple {
+    TypeTuple {
         paren_token: _i . paren_token,
         tys: FoldHelper::lift(_i . tys, |it| { _visitor.fold_type(it) }),
         lone_comma: _i . lone_comma,
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 237592f..edc842b 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -143,9 +143,9 @@
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_try(&mut self, i: &'ast ExprTry) { visit_expr_try(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup(&mut self, i: &'ast ExprTup) { visit_expr_tup(self, i) }
-# [ cfg ( feature = "full" ) ]
 fn visit_expr_tup_field(&mut self, i: &'ast ExprTupField) { visit_expr_tup_field(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) { visit_expr_tuple(self, i) }
 
 fn visit_expr_type(&mut self, i: &'ast ExprType) { visit_expr_type(self, i) }
 
@@ -345,7 +345,7 @@
 
 fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) { visit_type_trait_object(self, i) }
 
-fn visit_type_tup(&mut self, i: &'ast TypeTup) { visit_type_tup(self, i) }
+fn visit_type_tuple(&mut self, i: &'ast TypeTuple) { visit_type_tuple(self, i) }
 
 fn visit_un_op(&mut self, i: &'ast UnOp) { visit_un_op(self, i) }
 
@@ -820,8 +820,8 @@
         MethodCall(ref _binding_0, ) => {
             full!(_visitor.visit_expr_method_call(&* _binding_0));
         }
-        Tup(ref _binding_0, ) => {
-            full!(_visitor.visit_expr_tup(&* _binding_0));
+        Tuple(ref _binding_0, ) => {
+            full!(_visitor.visit_expr_tuple(&* _binding_0));
         }
         Binary(ref _binding_0, ) => {
             _visitor.visit_expr_binary(&* _binding_0);
@@ -995,17 +995,17 @@
     // Skipped field _i . question_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn visit_expr_tup<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTup) {
-    for el in (_i . args).iter() { let it = el.item(); _visitor.visit_expr(&it) };
-    // Skipped field _i . paren_token;
-    // Skipped field _i . lone_comma;
-}
-# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_tup_field<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTupField) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) {
+    for el in (_i . args).iter() { let it = el.item(); _visitor.visit_expr(&it) };
+    // Skipped field _i . paren_token;
+    // Skipped field _i . lone_comma;
+}
 
 pub fn visit_expr_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprType) {
     _visitor.visit_expr(&_i . expr);
@@ -1862,8 +1862,8 @@
         Never(ref _binding_0, ) => {
             _visitor.visit_type_never(&* _binding_0);
         }
-        Tup(ref _binding_0, ) => {
-            _visitor.visit_type_tup(&* _binding_0);
+        Tuple(ref _binding_0, ) => {
+            _visitor.visit_type_tuple(&* _binding_0);
         }
         Path(ref _binding_0, ) => {
             _visitor.visit_type_path(&* _binding_0);
@@ -1978,7 +1978,7 @@
     for el in (_i . bounds).iter() { let it = el.item(); _visitor.visit_type_param_bound(&it) };
 }
 
-pub fn visit_type_tup<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTup) {
+pub fn visit_type_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTuple) {
     // Skipped field _i . paren_token;
     for el in (_i . tys).iter() { let it = el.item(); _visitor.visit_type(&it) };
     // Skipped field _i . lone_comma;
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 2ac4861..027f4f4 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -143,9 +143,9 @@
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { visit_expr_try_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup_mut(&mut self, i: &mut ExprTup) { visit_expr_tup_mut(self, i) }
-# [ cfg ( feature = "full" ) ]
 fn visit_expr_tup_field_mut(&mut self, i: &mut ExprTupField) { visit_expr_tup_field_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) { visit_expr_tuple_mut(self, i) }
 
 fn visit_expr_type_mut(&mut self, i: &mut ExprType) { visit_expr_type_mut(self, i) }
 
@@ -345,7 +345,7 @@
 
 fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) { visit_type_trait_object_mut(self, i) }
 
-fn visit_type_tup_mut(&mut self, i: &mut TypeTup) { visit_type_tup_mut(self, i) }
+fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { visit_type_tuple_mut(self, i) }
 
 fn visit_un_op_mut(&mut self, i: &mut UnOp) { visit_un_op_mut(self, i) }
 
@@ -820,8 +820,8 @@
         MethodCall(ref mut _binding_0, ) => {
             full!(_visitor.visit_expr_method_call_mut(&mut * _binding_0));
         }
-        Tup(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_tup_mut(&mut * _binding_0));
+        Tuple(ref mut _binding_0, ) => {
+            full!(_visitor.visit_expr_tuple_mut(&mut * _binding_0));
         }
         Binary(ref mut _binding_0, ) => {
             _visitor.visit_expr_binary_mut(&mut * _binding_0);
@@ -995,17 +995,17 @@
     // Skipped field _i . question_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn visit_expr_tup_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTup) {
-    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
-    // Skipped field _i . paren_token;
-    // Skipped field _i . lone_comma;
-}
-# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_tup_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTupField) {
     _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
+    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
+    // Skipped field _i . paren_token;
+    // Skipped field _i . lone_comma;
+}
 
 pub fn visit_expr_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
     _visitor.visit_expr_mut(&mut _i . expr);
@@ -1862,8 +1862,8 @@
         Never(ref mut _binding_0, ) => {
             _visitor.visit_type_never_mut(&mut * _binding_0);
         }
-        Tup(ref mut _binding_0, ) => {
-            _visitor.visit_type_tup_mut(&mut * _binding_0);
+        Tuple(ref mut _binding_0, ) => {
+            _visitor.visit_type_tuple_mut(&mut * _binding_0);
         }
         Path(ref mut _binding_0, ) => {
             _visitor.visit_type_path_mut(&mut * _binding_0);
@@ -1978,7 +1978,7 @@
     for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_type_param_bound_mut(&mut it) };
 }
 
-pub fn visit_type_tup_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTup) {
+pub fn visit_type_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTuple) {
     // Skipped field _i . paren_token;
     for mut el in (_i . tys).iter_mut() { let mut it = el.item_mut(); _visitor.visit_type_mut(&mut it) };
     // Skipped field _i . lone_comma;
diff --git a/src/lib.rs b/src/lib.rs
index 71534e9..a9df002 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,7 @@
 
 mod expr;
 pub use expr::{Expr, ExprKind, ExprBox, ExprInPlace, ExprArray, ExprCall,
-               ExprMethodCall, ExprTup, ExprBinary, ExprUnary, ExprCast,
+               ExprMethodCall, ExprTuple, ExprBinary, ExprUnary, ExprCast,
                ExprType, ExprIf, ExprIfLet, ExprWhile, ExprWhileLet,
                ExprForLoop, ExprLoop, ExprMatch, ExprClosure, ExprBlock,
                ExprAssign, ExprAssignOp, ExprField, ExprTupField, ExprIndex,
@@ -87,7 +87,7 @@
              BareFnArgName, BareFnType, ReturnType, MutType, Mutability,
              ParenthesizedGenericArguments, Path, PathArguments, PathSegment,
              PolyTraitRef, QSelf, Type, TypeBinding, Unsafety, TypeSlice,
-             TypeArray, TypePtr, TypeReference, TypeBareFn, TypeNever, TypeTup,
+             TypeArray, TypePtr, TypeReference, TypeBareFn, TypeNever, TypeTuple,
              TypePath, TypeTraitObject, TypeImplTrait, TypeParen, TypeInfer,
              TypeGroup, GenericArgument};
 #[cfg(feature = "printing")]
diff --git a/src/ty.rs b/src/ty.rs
index 8dd0a96..c4f9b53 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -37,7 +37,7 @@
             pub bang_token: Token![!],
         }),
         /// A tuple (`(A, B, C, D, ...)`)
-        pub Tup(TypeTup {
+        pub Tuple(TypeTuple {
             pub paren_token: tokens::Paren,
             pub tys: Delimited<Type, Token![,]>,
             pub lone_comma: Option<Token![,]>,
@@ -367,7 +367,7 @@
     named!(ambig_ty(allow_plus: bool) -> Type, alt!(
         syn!(TypeGroup) => { Type::Group }
         |
-        // must be before TypeTup
+        // must be before TypeTuple
         syn!(TypeParen) => { Type::Paren }
         |
         // must be before TypePath
@@ -388,7 +388,7 @@
         |
         syn!(TypeNever) => { Type::Never }
         |
-        syn!(TypeTup) => { Type::Tup }
+        syn!(TypeTuple) => { Type::Tuple }
         |
         // Don't try parsing more than one trait bound if we aren't allowing it
         call!(TypeTraitObject::parse, allow_plus) => { Type::TraitObject }
@@ -507,10 +507,10 @@
         ));
     }
 
-    impl Synom for TypeTup {
+    impl Synom for TypeTuple {
         named!(parse -> Self, do_parse!(
             data: parens!(call!(Delimited::parse_terminated)) >>
-            (TypeTup {
+            (TypeTuple {
                 tys: data.0,
                 paren_token: data.1,
                 lone_comma: None, // TODO: does this just not parse?
@@ -899,7 +899,7 @@
         }
     }
 
-    impl ToTokens for TypeTup {
+    impl ToTokens for TypeTuple {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.paren_token.surround(tokens, |tokens| {
                 self.tys.to_tokens(tokens);