diff --git a/src/attr.rs b/src/attr.rs
index 393ffc8..d2ca870 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -94,8 +94,8 @@
 }
 
 impl Attribute {
-    /// Parses the tokens after the path as a [`MetaItem`](enum.MetaItem.html) if possible.
-    pub fn meta_item(&self) -> Option<MetaItem> {
+    /// Parses the tokens after the path as a [`Meta`](enum.Meta.html) if possible.
+    pub fn interpret_meta(&self) -> Option<Meta> {
         let name = if self.path.segments.len() == 1 {
             &self.path.segments.first().unwrap().value().ident
         } else {
@@ -103,7 +103,7 @@
         };
 
         if self.tts.is_empty() {
-            return Some(MetaItem::Term(*name));
+            return Some(Meta::Word(*name));
         }
 
         let tts = self.tts.clone().into_iter().collect::<Vec<_>>();
@@ -112,7 +112,7 @@
             if let TokenNode::Group(Delimiter::Parenthesis, ref ts) = tts[0].kind {
                 let tokens = ts.clone().into_iter().collect::<Vec<_>>();
                 if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
-                    return Some(MetaItem::List(MetaItemList {
+                    return Some(Meta::List(MetaList {
                         paren_token: token::Paren(tts[0].span),
                         ident: *name,
                         nested: nested_meta_items,
@@ -124,7 +124,7 @@
         if tts.len() == 2 {
             if let TokenNode::Op('=', Spacing::Alone) = tts[0].kind {
                 if let TokenNode::Literal(ref lit) = tts[1].kind {
-                    return Some(MetaItem::NameValue(MetaNameValue {
+                    return Some(Meta::NameValue(MetaNameValue {
                         ident: *name,
                         eq_token: Token![=]([tts[0].span]),
                         lit: Lit::new(lit.clone(), tts[1].span),
@@ -137,13 +137,13 @@
     }
 }
 
-fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMetaItem, &[TokenTree])> {
+fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> {
     assert!(!tts.is_empty());
 
     match tts[0].kind {
         TokenNode::Literal(ref lit) => {
             let lit = Lit::new(lit.clone(), tts[0].span);
-            Some((NestedMetaItem::Literal(lit), &tts[1..]))
+            Some((NestedMeta::Literal(lit), &tts[1..]))
         }
 
         TokenNode::Term(sym) => {
@@ -156,7 +156,7 @@
                             eq_token: Token![=]([tts[1].span]),
                             lit: Lit::new(lit.clone(), tts[2].span),
                         };
-                        return Some((MetaItem::NameValue(pair).into(), &tts[3..]));
+                        return Some((Meta::NameValue(pair).into(), &tts[3..]));
                     }
                 }
             }
@@ -166,12 +166,12 @@
                     let inner_tts = inner_tts.clone().into_iter().collect::<Vec<_>>();
                     return match list_of_nested_meta_items_from_tokens(&inner_tts) {
                         Some(nested_meta_items) => {
-                            let list = MetaItemList {
+                            let list = MetaList {
                                 ident: ident,
                                 paren_token: token::Paren(tts[1].span),
                                 nested: nested_meta_items,
                             };
-                            Some((MetaItem::List(list).into(), &tts[2..]))
+                            Some((Meta::List(list).into(), &tts[2..]))
                         }
 
                         None => None,
@@ -179,7 +179,7 @@
                 }
             }
 
-            Some((MetaItem::Term(ident).into(), &tts[1..]))
+            Some((Meta::Word(ident).into(), &tts[1..]))
         }
 
         _ => None,
@@ -188,7 +188,7 @@
 
 fn list_of_nested_meta_items_from_tokens(
     mut tts: &[TokenTree],
-) -> Option<Punctuated<NestedMetaItem, Token![,]>> {
+) -> Option<Punctuated<NestedMeta, Token![,]>> {
     let mut nested_meta_items = Punctuated::new();
     let mut first = true;
 
@@ -246,16 +246,16 @@
     /// A compile-time attribute item.
     ///
     /// E.g. `#[test]`, `#[derive(..)]` or `#[feature = "foo"]`
-    pub enum MetaItem {
+    pub enum Meta {
         /// Term meta item.
         ///
         /// E.g. `test` as in `#[test]`
-        pub Term(Ident),
+        pub Word(Ident),
 
         /// List meta item.
         ///
         /// E.g. `derive(..)` as in `#[derive(..)]`
-        pub List(MetaItemList {
+        pub List(MetaList {
             /// Name of this attribute.
             ///
             /// E.g. `derive` in `#[derive(..)]`
@@ -266,7 +266,7 @@
             /// Arguments to this attribute
             ///
             /// E.g. `..` in `#[derive(..)]`
-            pub nested: Punctuated<NestedMetaItem, Token![,]>,
+            pub nested: Punctuated<NestedMeta, Token![,]>,
         }),
 
         /// Name-value meta item.
@@ -288,16 +288,16 @@
     }
 }
 
-impl MetaItem {
+impl Meta {
     /// Name of the item.
     ///
     /// E.g. `test` as in `#[test]`, `derive` as in `#[derive(..)]`, and
     /// `feature` as in `#[feature = "foo"]`.
     pub fn name(&self) -> &str {
         match *self {
-            MetaItem::Term(ref name) => name.as_ref(),
-            MetaItem::NameValue(ref pair) => pair.ident.as_ref(),
-            MetaItem::List(ref list) => list.ident.as_ref(),
+            Meta::Word(ref name) => name.as_ref(),
+            Meta::NameValue(ref pair) => pair.ident.as_ref(),
+            Meta::List(ref list) => list.ident.as_ref(),
         }
     }
 }
@@ -306,11 +306,11 @@
     /// Possible values inside of compile-time attribute lists.
     ///
     /// E.g. the '..' in `#[name(..)]`.
-    pub enum NestedMetaItem {
-        /// A full `MetaItem`.
+    pub enum NestedMeta {
+        /// A full `Meta`.
         ///
-        /// E.g. `Copy` in `#[derive(Copy)]` would be a `MetaItem::Term(Ident::from("Copy"))`.
-        pub MetaItem(MetaItem),
+        /// E.g. `Copy` in `#[derive(Copy)]` would be a `Meta::Word(Ident::from("Copy"))`.
+        pub Meta(Meta),
 
         /// A Rust literal.
         ///
@@ -491,7 +491,7 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             // If this was a sugared doc, emit it in its original form instead of `#[doc = "..."]`
             if self.is_sugared_doc {
-                if let Some(MetaItem::NameValue(ref pair)) = self.meta_item() {
+                if let Some(Meta::NameValue(ref pair)) = self.interpret_meta() {
                     if pair.ident == "doc" {
                         if let Lit::Str(ref comment) = pair.lit {
                             tokens.append(TokenTree {
@@ -515,7 +515,7 @@
         }
     }
 
-    impl ToTokens for MetaItemList {
+    impl ToTokens for MetaList {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.ident.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 190e3b6..6c1d54b 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -272,9 +272,9 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn fold_member(&mut self, i: Member) -> Member { fold_member(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn fold_meta_item(&mut self, i: MetaItem) -> MetaItem { fold_meta_item(self, i) }
+fn fold_meta(&mut self, i: Meta) -> Meta { fold_meta(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn fold_meta_item_list(&mut self, i: MetaItemList) -> MetaItemList { fold_meta_item_list(self, i) }
+fn fold_meta_list(&mut self, i: MetaList) -> MetaList { fold_meta_list(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue { fold_meta_name_value(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -282,7 +282,7 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
 fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish { fold_method_turbofish(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn fold_nested_meta_item(&mut self, i: NestedMetaItem) -> NestedMetaItem { fold_nested_meta_item(self, i) }
+fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta { fold_nested_meta(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn fold_parenthesized_generic_arguments(&mut self, i: ParenthesizedGenericArguments) -> ParenthesizedGenericArguments { fold_parenthesized_generic_arguments(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
@@ -2101,31 +2101,31 @@
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn fold_meta_item<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaItem) -> MetaItem {
+pub fn fold_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: Meta) -> Meta {
     match _i {
-        MetaItem::Term(_binding_0, ) => {
-            MetaItem::Term (
+        Meta::Word(_binding_0, ) => {
+            Meta::Word (
                 _visitor.fold_ident(_binding_0),
             )
         }
-        MetaItem::List(_binding_0, ) => {
-            MetaItem::List (
-                _visitor.fold_meta_item_list(_binding_0),
+        Meta::List(_binding_0, ) => {
+            Meta::List (
+                _visitor.fold_meta_list(_binding_0),
             )
         }
-        MetaItem::NameValue(_binding_0, ) => {
-            MetaItem::NameValue (
+        Meta::NameValue(_binding_0, ) => {
+            Meta::NameValue (
                 _visitor.fold_meta_name_value(_binding_0),
             )
         }
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn fold_meta_item_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaItemList) -> MetaItemList {
-    MetaItemList {
+pub fn fold_meta_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaList) -> MetaList {
+    MetaList {
         ident: _visitor.fold_ident(_i . ident),
         paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
-        nested: FoldHelper::lift(_i . nested, |it| { _visitor.fold_nested_meta_item(it) }),
+        nested: FoldHelper::lift(_i . nested, |it| { _visitor.fold_nested_meta(it) }),
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -2156,15 +2156,15 @@
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn fold_nested_meta_item<V: Fold + ?Sized>(_visitor: &mut V, _i: NestedMetaItem) -> NestedMetaItem {
+pub fn fold_nested_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: NestedMeta) -> NestedMeta {
     match _i {
-        NestedMetaItem::MetaItem(_binding_0, ) => {
-            NestedMetaItem::MetaItem (
-                _visitor.fold_meta_item(_binding_0),
+        NestedMeta::Meta(_binding_0, ) => {
+            NestedMeta::Meta (
+                _visitor.fold_meta(_binding_0),
             )
         }
-        NestedMetaItem::Literal(_binding_0, ) => {
-            NestedMetaItem::Literal (
+        NestedMeta::Literal(_binding_0, ) => {
+            NestedMeta::Literal (
                 _visitor.fold_lit(_binding_0),
             )
         }
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 5f0cb02..3ca8e38 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -270,9 +270,9 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_member(&mut self, i: &'ast Member) { visit_member(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_meta_item(&mut self, i: &'ast MetaItem) { visit_meta_item(self, i) }
+fn visit_meta(&mut self, i: &'ast Meta) { visit_meta(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_meta_item_list(&mut self, i: &'ast MetaItemList) { visit_meta_item_list(self, i) }
+fn visit_meta_list(&mut self, i: &'ast MetaList) { visit_meta_list(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) { visit_meta_name_value(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -280,7 +280,7 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
 fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) { visit_method_turbofish(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_nested_meta_item(&mut self, i: &'ast NestedMetaItem) { visit_nested_meta_item(self, i) }
+fn visit_nested_meta(&mut self, i: &'ast NestedMeta) { visit_nested_meta(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
@@ -1666,24 +1666,24 @@
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_meta_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaItem) {
+pub fn visit_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Meta) {
     match *_i {
-        MetaItem::Term(ref _binding_0, ) => {
+        Meta::Word(ref _binding_0, ) => {
             _visitor.visit_ident(_binding_0);
         }
-        MetaItem::List(ref _binding_0, ) => {
-            _visitor.visit_meta_item_list(_binding_0);
+        Meta::List(ref _binding_0, ) => {
+            _visitor.visit_meta_list(_binding_0);
         }
-        MetaItem::NameValue(ref _binding_0, ) => {
+        Meta::NameValue(ref _binding_0, ) => {
             _visitor.visit_meta_name_value(_binding_0);
         }
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_meta_item_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaItemList) {
+pub fn visit_meta_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaList) {
     _visitor.visit_ident(& _i . ident);
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in Punctuated::pairs(& _i . nested) { let it = el.value(); _visitor.visit_nested_meta_item(it) };
+    for el in Punctuated::pairs(& _i . nested) { let it = el.value(); _visitor.visit_nested_meta(it) };
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 pub fn visit_meta_name_value<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaNameValue) {
@@ -1707,12 +1707,12 @@
     tokens_helper(_visitor, &(& _i . gt_token).0);
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_nested_meta_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMetaItem) {
+pub fn visit_nested_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMeta) {
     match *_i {
-        NestedMetaItem::MetaItem(ref _binding_0, ) => {
-            _visitor.visit_meta_item(_binding_0);
+        NestedMeta::Meta(ref _binding_0, ) => {
+            _visitor.visit_meta(_binding_0);
         }
-        NestedMetaItem::Literal(ref _binding_0, ) => {
+        NestedMeta::Literal(ref _binding_0, ) => {
             _visitor.visit_lit(_binding_0);
         }
     }
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 96f3338..e11e97d 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -271,9 +271,9 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_member_mut(&mut self, i: &mut Member) { visit_member_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_meta_item_mut(&mut self, i: &mut MetaItem) { visit_meta_item_mut(self, i) }
+fn visit_meta_mut(&mut self, i: &mut Meta) { visit_meta_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_meta_item_list_mut(&mut self, i: &mut MetaItemList) { visit_meta_item_list_mut(self, i) }
+fn visit_meta_list_mut(&mut self, i: &mut MetaList) { visit_meta_list_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) { visit_meta_name_value_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -281,7 +281,7 @@
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
 fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) { visit_method_turbofish_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_nested_meta_item_mut(&mut self, i: &mut NestedMetaItem) { visit_nested_meta_item_mut(self, i) }
+fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) { visit_nested_meta_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments_mut(self, i) }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
@@ -1667,24 +1667,24 @@
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_meta_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItem) {
+pub fn visit_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Meta) {
     match *_i {
-        MetaItem::Term(ref mut _binding_0, ) => {
+        Meta::Word(ref mut _binding_0, ) => {
             _visitor.visit_ident_mut(_binding_0);
         }
-        MetaItem::List(ref mut _binding_0, ) => {
-            _visitor.visit_meta_item_list_mut(_binding_0);
+        Meta::List(ref mut _binding_0, ) => {
+            _visitor.visit_meta_list_mut(_binding_0);
         }
-        MetaItem::NameValue(ref mut _binding_0, ) => {
+        Meta::NameValue(ref mut _binding_0, ) => {
             _visitor.visit_meta_name_value_mut(_binding_0);
         }
     }
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_meta_item_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItemList) {
+pub fn visit_meta_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaList) {
     _visitor.visit_ident_mut(& mut _i . ident);
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in Punctuated::pairs_mut(& mut _i . nested) { let it = el.value_mut(); _visitor.visit_nested_meta_item_mut(it) };
+    for mut el in Punctuated::pairs_mut(& mut _i . nested) { let it = el.value_mut(); _visitor.visit_nested_meta_mut(it) };
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
 pub fn visit_meta_name_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
@@ -1708,12 +1708,12 @@
     tokens_helper(_visitor, &mut (& mut _i . gt_token).0);
 }
 # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_nested_meta_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMetaItem) {
+pub fn visit_nested_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMeta) {
     match *_i {
-        NestedMetaItem::MetaItem(ref mut _binding_0, ) => {
-            _visitor.visit_meta_item_mut(_binding_0);
+        NestedMeta::Meta(ref mut _binding_0, ) => {
+            _visitor.visit_meta_mut(_binding_0);
         }
-        NestedMetaItem::Literal(ref mut _binding_0, ) => {
+        NestedMeta::Literal(ref mut _binding_0, ) => {
             _visitor.visit_lit_mut(_binding_0);
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index b2075a5..948dd3e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -281,7 +281,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 mod attr;
 #[cfg(any(feature = "full", feature = "derive"))]
-pub use attr::{AttrStyle, Attribute, MetaItem, MetaItemList, MetaNameValue, NestedMetaItem};
+pub use attr::{AttrStyle, Attribute, Meta, MetaList, MetaNameValue, NestedMeta};
 
 #[cfg(any(feature = "full", feature = "derive"))]
 mod data;
diff --git a/tests/test_derive_input.rs b/tests/test_derive_input.rs
index 5772a94..9079b4a 100644
--- a/tests/test_derive_input.rs
+++ b/tests/test_derive_input.rs
@@ -154,16 +154,16 @@
 
     assert_eq!(expected, actual);
 
-    let expected_meta_item: MetaItem = MetaItemList {
+    let expected_meta_item: Meta = MetaList {
         ident: "derive".into(),
         paren_token: Default::default(),
         nested: punctuated![
-            NestedMetaItem::MetaItem(MetaItem::Term("Debug".into())),
-            NestedMetaItem::MetaItem(MetaItem::Term("Clone".into())),
+            NestedMeta::Meta(Meta::Word("Debug".into())),
+            NestedMeta::Meta(Meta::Word("Clone".into())),
         ],
     }.into();
 
-    assert_eq!(expected_meta_item, actual.attrs[0].meta_item().unwrap());
+    assert_eq!(expected_meta_item, actual.attrs[0].interpret_meta().unwrap());
 }
 
 #[test]
@@ -341,13 +341,13 @@
                 Default::default(),
             )),
         }.into(),
-        MetaItem::Term("must_use".into()),
+        Meta::Word("must_use".into()),
     ];
 
     let actual_meta_items: Vec<_> = actual
         .attrs
         .into_iter()
-        .map(|attr| attr.meta_item().unwrap())
+        .map(|attr| attr.interpret_meta().unwrap())
         .collect();
 
     assert_eq!(expected_meta_items, actual_meta_items);
@@ -413,7 +413,7 @@
 
     assert_eq!(expected, actual);
 
-    assert!(actual.attrs[0].meta_item().is_none());
+    assert!(actual.attrs[0].interpret_meta().is_none());
 }
 
 #[test]
@@ -451,7 +451,7 @@
 
     assert_eq!(expected, actual);
 
-    assert!(actual.attrs[0].meta_item().is_none());
+    assert!(actual.attrs[0].interpret_meta().is_none());
 }
 
 #[test]
@@ -489,7 +489,7 @@
 
     assert_eq!(expected, actual);
 
-    assert!(actual.attrs[0].meta_item().is_none());
+    assert!(actual.attrs[0].interpret_meta().is_none());
 }
 
 #[test]
diff --git a/tests/test_meta_item.rs b/tests/test_meta_item.rs
index e0378bc..8546733 100644
--- a/tests/test_meta_item.rs
+++ b/tests/test_meta_item.rs
@@ -24,7 +24,7 @@
 
 #[test]
 fn test_meta_item_word() {
-    run_test("#[foo]", MetaItem::Term("foo".into()))
+    run_test("#[foo]", Meta::Word("foo".into()))
 }
 
 #[test]
@@ -43,10 +43,10 @@
 fn test_meta_item_list_lit() {
     run_test(
         "#[foo(5)]",
-        MetaItemList {
+        MetaList {
             ident: "foo".into(),
             paren_token: Default::default(),
-            nested: punctuated![NestedMetaItem::Literal(lit(Literal::integer(5)))],
+            nested: punctuated![NestedMeta::Literal(lit(Literal::integer(5)))],
         },
     )
 }
@@ -55,10 +55,10 @@
 fn test_meta_item_list_word() {
     run_test(
         "#[foo(bar)]",
-        MetaItemList {
+        MetaList {
             ident: "foo".into(),
             paren_token: Default::default(),
-            nested: punctuated![NestedMetaItem::MetaItem(MetaItem::Term("bar".into()))],
+            nested: punctuated![NestedMeta::Meta(Meta::Word("bar".into()))],
         },
     )
 }
@@ -67,11 +67,11 @@
 fn test_meta_item_list_name_value() {
     run_test(
         "#[foo(bar = 5)]",
-        MetaItemList {
+        MetaList {
             ident: "foo".into(),
             paren_token: Default::default(),
             nested: punctuated![
-                NestedMetaItem::MetaItem(
+                NestedMeta::Meta(
                     MetaNameValue {
                         ident: "bar".into(),
                         eq_token: Default::default(),
@@ -87,24 +87,24 @@
 fn test_meta_item_multiple() {
     run_test(
         "#[foo(word, name = 5, list(name2 = 6), word2)]",
-        MetaItemList {
+        MetaList {
             ident: "foo".into(),
             paren_token: Default::default(),
             nested: punctuated![
-                NestedMetaItem::MetaItem(MetaItem::Term("word".into())),
-                NestedMetaItem::MetaItem(
+                NestedMeta::Meta(Meta::Word("word".into())),
+                NestedMeta::Meta(
                     MetaNameValue {
                         ident: "name".into(),
                         eq_token: Default::default(),
                         lit: lit(Literal::integer(5)),
                     }.into(),
                 ),
-                NestedMetaItem::MetaItem(
-                    MetaItemList {
+                NestedMeta::Meta(
+                    MetaList {
                         ident: "list".into(),
                         paren_token: Default::default(),
                         nested: punctuated![
-                            NestedMetaItem::MetaItem(
+                            NestedMeta::Meta(
                                 MetaNameValue {
                                     ident: "name2".into(),
                                     eq_token: Default::default(),
@@ -114,13 +114,13 @@
                         ],
                     }.into(),
                 ),
-                NestedMetaItem::MetaItem(MetaItem::Term("word2".into())),
+                NestedMeta::Meta(Meta::Word("word2".into())),
             ],
         },
     )
 }
 
-fn run_test<T: Into<MetaItem>>(input: &str, expected: T) {
+fn run_test<T: Into<Meta>>(input: &str, expected: T) {
     let tokens = input.parse::<TokenStream>().unwrap();
     let buf = TokenBuffer::new2(tokens);
     let attr = match Attribute::parse_outer(buf.begin()) {
@@ -130,5 +130,5 @@
         }
         Err(err) => panic!(err),
     };
-    assert_eq!(expected.into(), attr.meta_item().unwrap());
+    assert_eq!(expected.into(), attr.interpret_meta().unwrap());
 }