diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 5a5e5bf..5209789 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -483,6 +483,10 @@
         fold_item_trait(self, i)
     }
     #[cfg(feature = "full")]
+    fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias {
+        fold_item_trait_alias(self, i)
+    }
+    #[cfg(feature = "full")]
     fn fold_item_type(&mut self, i: ItemType) -> ItemType {
         fold_item_type(self, i)
     }
@@ -1986,6 +1990,9 @@
         Item::Enum(_binding_0) => Item::Enum(_visitor.fold_item_enum(_binding_0)),
         Item::Union(_binding_0) => Item::Union(_visitor.fold_item_union(_binding_0)),
         Item::Trait(_binding_0) => Item::Trait(_visitor.fold_item_trait(_binding_0)),
+        Item::TraitAlias(_binding_0) => {
+            Item::TraitAlias(_visitor.fold_item_trait_alias(_binding_0))
+        }
         Item::Impl(_binding_0) => Item::Impl(_visitor.fold_item_impl(_binding_0)),
         Item::Macro(_binding_0) => Item::Macro(_visitor.fold_item_macro(_binding_0)),
         Item::Macro2(_binding_0) => Item::Macro2(_visitor.fold_item_macro2(_binding_0)),
@@ -2183,6 +2190,22 @@
     }
 }
 #[cfg(feature = "full")]
+pub fn fold_item_trait_alias<V: Fold + ?Sized>(
+    _visitor: &mut V,
+    _i: ItemTraitAlias,
+) -> ItemTraitAlias {
+    ItemTraitAlias {
+        attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
+        vis: _visitor.fold_visibility(_i.vis),
+        trait_token: Token ! [ trait ](tokens_helper(_visitor, &_i.trait_token.span)),
+        ident: _visitor.fold_ident(_i.ident),
+        generics: _visitor.fold_generics(_i.generics),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
+        bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
+    }
+}
+#[cfg(feature = "full")]
 pub fn fold_item_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemType) -> ItemType {
     ItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 6bf7a68..502e0f2 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -483,6 +483,10 @@
         visit_item_trait(self, i)
     }
     #[cfg(feature = "full")]
+    fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) {
+        visit_item_trait_alias(self, i)
+    }
+    #[cfg(feature = "full")]
     fn visit_item_type(&mut self, i: &'ast ItemType) {
         visit_item_type(self, i)
     }
@@ -2211,6 +2215,9 @@
         Item::Trait(ref _binding_0) => {
             _visitor.visit_item_trait(_binding_0);
         }
+        Item::TraitAlias(ref _binding_0) => {
+            _visitor.visit_item_trait_alias(_binding_0);
+        }
         Item::Impl(ref _binding_0) => {
             _visitor.visit_item_impl(_binding_0);
         }
@@ -2459,6 +2466,25 @@
     }
 }
 #[cfg(feature = "full")]
+pub fn visit_item_trait_alias<'ast, V: Visit<'ast> + ?Sized>(
+    _visitor: &mut V,
+    _i: &'ast ItemTraitAlias,
+) {
+    for it in &_i.attrs {
+        _visitor.visit_attribute(it)
+    }
+    _visitor.visit_visibility(&_i.vis);
+    tokens_helper(_visitor, &_i.trait_token.span);
+    _visitor.visit_ident(&_i.ident);
+    _visitor.visit_generics(&_i.generics);
+    tokens_helper(_visitor, &_i.eq_token.spans);
+    for el in Punctuated::pairs(&_i.bounds) {
+        let it = el.value();
+        _visitor.visit_type_param_bound(it)
+    }
+    tokens_helper(_visitor, &_i.semi_token.spans);
+}
+#[cfg(feature = "full")]
 pub fn visit_item_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemType) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 2b445c7..8eb19f8 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -487,6 +487,10 @@
         visit_item_trait_mut(self, i)
     }
     #[cfg(feature = "full")]
+    fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) {
+        visit_item_trait_alias_mut(self, i)
+    }
+    #[cfg(feature = "full")]
     fn visit_item_type_mut(&mut self, i: &mut ItemType) {
         visit_item_type_mut(self, i)
     }
@@ -2167,6 +2171,9 @@
         Item::Trait(ref mut _binding_0) => {
             _visitor.visit_item_trait_mut(_binding_0);
         }
+        Item::TraitAlias(ref mut _binding_0) => {
+            _visitor.visit_item_trait_alias_mut(_binding_0);
+        }
         Item::Impl(ref mut _binding_0) => {
             _visitor.visit_item_impl_mut(_binding_0);
         }
@@ -2412,6 +2419,22 @@
     }
 }
 #[cfg(feature = "full")]
+pub fn visit_item_trait_alias_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTraitAlias) {
+    for it in &mut _i.attrs {
+        _visitor.visit_attribute_mut(it)
+    }
+    _visitor.visit_visibility_mut(&mut _i.vis);
+    tokens_helper(_visitor, &mut _i.trait_token.span);
+    _visitor.visit_ident_mut(&mut _i.ident);
+    _visitor.visit_generics_mut(&mut _i.generics);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
+    for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
+        let it = el.value_mut();
+        _visitor.visit_type_param_bound_mut(it)
+    }
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
+}
+#[cfg(feature = "full")]
 pub fn visit_item_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemType) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
diff --git a/src/item.rs b/src/item.rs
index c0b9325..3fe7c70 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -206,6 +206,20 @@
             pub items: Vec<TraitItem>,
         }),
 
+        /// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
+        pub TraitAlias(ItemTraitAlias {
+            pub attrs: Vec<Attribute>,
+            pub vis: Visibility,
+            pub trait_token: Token![trait],
+            pub ident: Ident,
+            pub generics: Generics,
+            pub eq_token: Token![=],
+            pub bounds: Punctuated<TypeParamBound, Token![+]>,
+            pub semi_token: Token![;],
+        }),
+
         /// An impl block providing trait or associated items: `impl<A> Trait
         /// for Data<A> { ... }`.
         ///
@@ -1478,6 +1492,43 @@
         }
     }
 
+    impl Parse for ItemTraitAlias {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let attrs = input.call(Attribute::parse_outer)?;
+            let vis: Visibility = input.parse()?;
+            let trait_token: Token![trait] = input.parse()?;
+            let ident: Ident = input.parse()?;
+            let mut generics: Generics = input.parse()?;
+            let eq_token: Token![=] = input.parse()?;
+
+            let mut bounds = Punctuated::new();
+            loop {
+                if input.peek(Token![where]) || input.peek(Token![;]) {
+                    break;
+                }
+                bounds.push_value(input.parse()?);
+                if input.peek(Token![where]) || input.peek(Token![;]) {
+                    break;
+                }
+                bounds.push_punct(input.parse()?);
+            }
+
+            generics.where_clause = input.parse()?;
+            let semi_token: Token![;] = input.parse()?;
+
+            Ok(ItemTraitAlias {
+                attrs: attrs,
+                vis: vis,
+                trait_token: trait_token,
+                ident: ident,
+                generics: generics,
+                eq_token: eq_token,
+                bounds: bounds,
+                semi_token: semi_token,
+            })
+        }
+    }
+
     impl Parse for TraitItem {
         fn parse(input: ParseStream) -> Result<Self> {
             let ahead = input.fork();
@@ -2131,6 +2182,20 @@
         }
     }
 
+    impl ToTokens for ItemTraitAlias {
+        fn to_tokens(&self, tokens: &mut TokenStream) {
+            tokens.append_all(self.attrs.outer());
+            self.vis.to_tokens(tokens);
+            self.trait_token.to_tokens(tokens);
+            self.ident.to_tokens(tokens);
+            self.generics.to_tokens(tokens);
+            self.eq_token.to_tokens(tokens);
+            self.bounds.to_tokens(tokens);
+            self.generics.where_clause.to_tokens(tokens);
+            self.semi_token.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for ItemImpl {
         fn to_tokens(&self, tokens: &mut TokenStream) {
             tokens.append_all(self.attrs.outer());
diff --git a/src/lib.rs b/src/lib.rs
index 59bc773..a4f3dec 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -375,9 +375,10 @@
     ForeignItemStatic, ForeignItemType, ForeignItemVerbatim, ImplItem, ImplItemConst,
     ImplItemExistential, ImplItemMacro, ImplItemMethod, ImplItemType, ImplItemVerbatim, Item,
     ItemConst, ItemEnum, ItemExistential, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl,
-    ItemMacro, ItemMacro2, ItemMod, ItemStatic, ItemStruct, ItemTrait, ItemType, ItemUnion,
-    ItemUse, ItemVerbatim, MethodSig, TraitItem, TraitItemConst, TraitItemMacro, TraitItemMethod,
-    TraitItemType, TraitItemVerbatim, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree,
+    ItemMacro, ItemMacro2, ItemMod, ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType,
+    ItemUnion, ItemUse, ItemVerbatim, MethodSig, TraitItem, TraitItemConst, TraitItemMacro,
+    TraitItemMethod, TraitItemType, TraitItemVerbatim, UseGlob, UseGroup, UseName, UsePath,
+    UseRename, UseTree,
 };
 
 #[cfg(feature = "full")]