diff --git a/codegen/src/main.rs b/codegen/src/main.rs
index ac674a0..7f24774 100644
--- a/codegen/src/main.rs
+++ b/codegen/src/main.rs
@@ -1026,6 +1026,8 @@
 /// See the [module documentation] for details.
 ///
 /// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `\"fold\"` feature.*
 pub trait Fold {{
 {fold_trait}
 }}
@@ -1086,6 +1088,8 @@
 /// See the [module documentation] for details.
 ///
 /// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `\"visit\"` feature.*
 pub trait Visit<'ast> {{
 {visit_trait}
 }}
@@ -1122,6 +1126,8 @@
 /// See the [module documentation] for details.
 ///
 /// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `\"visit-mut\"` feature.*
 pub trait VisitMut {{
 {visit_mut_trait}
 }}
diff --git a/src/attr.rs b/src/attr.rs
index bd104d8..06af8a5 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -21,6 +21,9 @@
 ast_struct! {
     /// An attribute like `#[repr(transparent)]`.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax
     ///
     /// Rust has six types of attributes.
@@ -225,6 +228,9 @@
     /// Distinguishes between attributes that decorate an item and attributes
     /// that are contained within an item.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Outer attributes
     ///
     /// - `#[repr(transparent)]`
@@ -246,6 +252,9 @@
 ast_enum_of_structs! {
     /// Content of a compile-time structured attribute.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// ## Word
     ///
     /// A meta word is like the `test` in `#[test]`.
@@ -267,12 +276,18 @@
     pub enum Meta {
         pub Word(Ident),
         /// A structured list within an attribute, like `derive(Copy, Clone)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub List(MetaList {
             pub ident: Ident,
             pub paren_token: token::Paren,
             pub nested: Punctuated<NestedMeta, Token![,]>,
         }),
         /// A name-value pair within an attribute, like `feature = "nightly"`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub NameValue(MetaNameValue {
             pub ident: Ident,
             pub eq_token: Token![=],
@@ -297,6 +312,9 @@
 
 ast_enum_of_structs! {
     /// Element of a compile-time attribute list.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum NestedMeta {
         /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which
         /// would be a nested `Meta::Word`.
diff --git a/src/buffer.rs b/src/buffer.rs
index 7ddb118..6b05d50 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -14,6 +14,8 @@
 //!
 //! [`Synom`]: ../synom/trait.Synom.html
 //!
+//! *This module is available if Syn is built with the `"parsing"` feature.*
+//!
 //! # Example
 //!
 //! This example shows a basic token parser for parsing a token stream without
@@ -154,6 +156,8 @@
 /// See the [module documentation] for an example of `TokenBuffer` in action.
 ///
 /// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
 pub struct TokenBuffer {
     // NOTE: Do not derive clone on this - there are raw pointers inside which
     // will be messed up. Moving the `TokenBuffer` itself is safe as the actual
@@ -246,6 +250,8 @@
 /// See the [module documentation] for an example of a `Cursor` in action.
 ///
 /// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Cursor<'a> {
     /// The current entry which the `Cursor` is pointing at.
diff --git a/src/data.rs b/src/data.rs
index 77dc725..004a938 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -11,6 +11,9 @@
 
 ast_struct! {
     /// An enum variant.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Variant {
         /// Attributes tagged on the variant.
         pub attrs: Vec<Attribute>,
@@ -29,6 +32,9 @@
 ast_enum_of_structs! {
     /// Data stored within an enum variant or struct.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -37,12 +43,18 @@
     pub enum Fields {
         /// Named fields of a struct or struct variant such as `Point { x: f64,
         /// y: f64 }`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Named(FieldsNamed {
             pub brace_token: token::Brace,
             pub named: Punctuated<Field, Token![,]>,
         }),
 
         /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Unnamed(FieldsUnnamed {
             pub paren_token: token::Paren,
             pub unnamed: Punctuated<Field, Token![,]>,
@@ -55,6 +67,9 @@
 
 ast_struct! {
     /// A field of a struct or enum variant.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Field {
         /// Attributes tagged on the field.
         pub attrs: Vec<Attribute>,
@@ -78,6 +93,9 @@
     /// The visibility level of an item: inherited or `pub` or
     /// `pub(restricted)`.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -85,11 +103,17 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum Visibility {
         /// A public visibility level: `pub`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Public(VisPublic {
             pub pub_token: Token![pub],
         }),
 
         /// A crate-level visibility: `pub(crate)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Crate(VisCrate {
             pub pub_token: Token![pub],
             pub paren_token: token::Paren,
@@ -98,6 +122,9 @@
 
         /// A visibility level restricted to some path: `pub(self)` or
         /// `pub(super)` or `pub(in some::module)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Restricted(VisRestricted {
             pub pub_token: Token![pub],
             pub paren_token: token::Paren,
diff --git a/src/derive.rs b/src/derive.rs
index ea8ffdc..3ad893d 100644
--- a/src/derive.rs
+++ b/src/derive.rs
@@ -11,6 +11,8 @@
 
 ast_struct! {
     /// Data structure sent to a `proc_macro_derive` macro.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` feature.*
     pub struct DeriveInput {
         /// Attributes tagged on the whole struct or enum.
         pub attrs: Vec<Attribute>,
@@ -32,6 +34,8 @@
 ast_enum_of_structs! {
     /// The storage of a struct, enum or union data structure.
     ///
+    /// *This type is available if Syn is built with the `"derive"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -39,6 +43,9 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum Data {
         /// A struct input to a `proc_macro_derive` macro.
+        ///
+        /// *This type is available if Syn is built with the `"derive"`
+        /// feature.*
         pub Struct(DataStruct {
             pub struct_token: Token![struct],
             pub fields: Fields,
@@ -46,6 +53,9 @@
         }),
 
         /// An enum input to a `proc_macro_derive` macro.
+        ///
+        /// *This type is available if Syn is built with the `"derive"`
+        /// feature.*
         pub Enum(DataEnum {
             pub enum_token: Token![enum],
             pub brace_token: token::Brace,
@@ -53,6 +63,9 @@
         }),
 
         /// A tagged union input to a `proc_macro_derive` macro.
+        ///
+        /// *This type is available if Syn is built with the `"derive"`
+        /// feature.*
         pub Union(DataUnion {
             pub union_token: Token![union],
             pub fields: FieldsNamed,
diff --git a/src/error.rs b/src/error.rs
index 2abfbc4..23d2a1a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -15,6 +15,8 @@
 /// Refer to the [module documentation] for details about parsing in Syn.
 ///
 /// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
 pub type PResult<'a, O> = Result<(O, Cursor<'a>), ParseError>;
 
 /// An error with a default error message.
@@ -29,6 +31,8 @@
 /// Refer to the [module documentation] for details about parsing in Syn.
 ///
 /// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
 #[derive(Debug)]
 pub struct ParseError(Option<String>);
 
diff --git a/src/expr.rs b/src/expr.rs
index 5f48b2c..3f18fa4 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -19,6 +19,9 @@
 ast_enum_of_structs! {
     /// A Rust expression.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enums
     ///
     /// This type is a syntax tree enum. In Syn this and other syntax tree enums
@@ -102,6 +105,8 @@
     /// `receiver.receiver` or `pat.pat` or `cond.cond`.
     pub enum Expr {
         /// A box expression: `box f`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Box(ExprBox #full {
             pub attrs: Vec<Attribute>,
             pub box_token: Token![box],
@@ -109,6 +114,8 @@
         }),
 
         /// A placement expression: `place <- value`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub InPlace(ExprInPlace #full {
             pub attrs: Vec<Attribute>,
             pub place: Box<Expr>,
@@ -117,6 +124,8 @@
         }),
 
         /// A slice literal expression: `[a, b, c, d]`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Array(ExprArray #full {
             pub attrs: Vec<Attribute>,
             pub bracket_token: token::Bracket,
@@ -124,6 +133,9 @@
         }),
 
         /// A function call expression: `invoke(a, b)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Call(ExprCall {
             pub attrs: Vec<Attribute>,
             pub func: Box<Expr>,
@@ -132,6 +144,8 @@
         }),
 
         /// A method call expression: `x.foo::<T>(a, b)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub MethodCall(ExprMethodCall #full {
             pub attrs: Vec<Attribute>,
             pub receiver: Box<Expr>,
@@ -143,6 +157,8 @@
         }),
 
         /// A tuple expression: `(a, b, c, d)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Tuple(ExprTuple #full {
             pub attrs: Vec<Attribute>,
             pub paren_token: token::Paren,
@@ -150,6 +166,9 @@
         }),
 
         /// A binary operation: `a + b`, `a * b`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Binary(ExprBinary {
             pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
@@ -158,6 +177,9 @@
         }),
 
         /// A unary operation: `!x`, `*x`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Unary(ExprUnary {
             pub attrs: Vec<Attribute>,
             pub op: UnOp,
@@ -165,12 +187,18 @@
         }),
 
         /// A literal in place of an expression: `1`, `"foo"`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Lit(ExprLit {
             pub attrs: Vec<Attribute>,
             pub lit: Lit,
         }),
 
         /// A cast expression: `foo as f64`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Cast(ExprCast {
             pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
@@ -179,6 +207,8 @@
         }),
 
         /// A type ascription expression: `foo: f64`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Type(ExprType #full {
             pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
@@ -191,6 +221,8 @@
         ///
         /// The `else` branch expression may only be an `If`, `IfLet`, or
         /// `Block` expression, not any of the other types of expression.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub If(ExprIf #full {
             pub attrs: Vec<Attribute>,
             pub if_token: Token![if],
@@ -204,6 +236,8 @@
         ///
         /// The `else` branch expression may only be an `If`, `IfLet`, or
         /// `Block` expression, not any of the other types of expression.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub IfLet(ExprIfLet #full {
             pub attrs: Vec<Attribute>,
             pub if_token: Token![if],
@@ -216,6 +250,8 @@
         }),
 
         /// A while loop: `while expr { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub While(ExprWhile #full {
             pub attrs: Vec<Attribute>,
             pub label: Option<Label>,
@@ -225,6 +261,8 @@
         }),
 
         /// A while-let loop: `while let pat = expr { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub WhileLet(ExprWhileLet #full {
             pub attrs: Vec<Attribute>,
             pub label: Option<Label>,
@@ -237,6 +275,8 @@
         }),
 
         /// A for loop: `for pat in expr { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub ForLoop(ExprForLoop #full {
             pub attrs: Vec<Attribute>,
             pub label: Option<Label>,
@@ -248,6 +288,8 @@
         }),
 
         /// Conditionless loop: `loop { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Loop(ExprLoop #full {
             pub attrs: Vec<Attribute>,
             pub label: Option<Label>,
@@ -256,6 +298,8 @@
         }),
 
         /// A `match` expression: `match n { Some(n) => {}, None => {} }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Match(ExprMatch #full {
             pub attrs: Vec<Attribute>,
             pub match_token: Token![match],
@@ -265,6 +309,8 @@
         }),
 
         /// A closure expression: `|a, b| a + b`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Closure(ExprClosure #full {
             pub attrs: Vec<Attribute>,
             pub capture: Option<Token![move]>,
@@ -276,6 +322,8 @@
         }),
 
         /// An unsafe block: `unsafe { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Unsafe(ExprUnsafe #full {
             pub attrs: Vec<Attribute>,
             pub unsafe_token: Token![unsafe],
@@ -283,12 +331,16 @@
         }),
 
         /// A blocked scope: `{ ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Block(ExprBlock #full {
             pub attrs: Vec<Attribute>,
             pub block: Block,
         }),
 
         /// An assignment expression: `a = compute()`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Assign(ExprAssign #full {
             pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
@@ -297,6 +349,8 @@
         }),
 
         /// A compound assignment expression: `counter += 1`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub AssignOp(ExprAssignOp #full {
             pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
@@ -306,6 +360,8 @@
 
         /// Access of a named struct field (`obj.k`) or unnamed tuple struct
         /// field (`obj.0`).
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Field(ExprField #full {
             pub attrs: Vec<Attribute>,
             pub base: Box<Expr>,
@@ -314,6 +370,9 @@
         }),
 
         /// A square bracketed indexing expression: `vector[2]`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Index(ExprIndex {
             pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
@@ -322,6 +381,8 @@
         }),
 
         /// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Range(ExprRange #full {
             pub attrs: Vec<Attribute>,
             pub from: Option<Box<Expr>>,
@@ -333,6 +394,9 @@
         /// parameters and a qualified self-type.
         ///
         /// A plain identifier like `x` is a path of length 1.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Path(ExprPath {
             pub attrs: Vec<Attribute>,
             pub qself: Option<QSelf>,
@@ -340,6 +404,8 @@
         }),
 
         /// A referencing operation: `&a` or `&mut a`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub AddrOf(ExprAddrOf #full {
             pub attrs: Vec<Attribute>,
             pub and_token: Token![&],
@@ -349,6 +415,8 @@
 
         /// A `break`, with an optional label to break and an optional
         /// expression.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Break(ExprBreak #full {
             pub attrs: Vec<Attribute>,
             pub break_token: Token![break],
@@ -357,6 +425,8 @@
         }),
 
         /// A `continue`, with an optional label.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Continue(ExprContinue #full {
             pub attrs: Vec<Attribute>,
             pub continue_token: Token![continue],
@@ -364,6 +434,8 @@
         }),
 
         /// A `return`, with an optional value to be returned.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Return(ExprReturn #full {
             pub attrs: Vec<Attribute>,
             pub return_token: Token![return],
@@ -371,6 +443,8 @@
         }),
 
         /// A macro invocation expression: `format!("{}", q)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro(ExprMacro #full {
             pub attrs: Vec<Attribute>,
             pub mac: Macro,
@@ -380,6 +454,8 @@
         ///
         /// The `rest` provides the value of the remaining fields as in `S { a:
         /// 1, b: 1, ..rest }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Struct(ExprStruct #full {
             pub attrs: Vec<Attribute>,
             pub path: Path,
@@ -390,6 +466,8 @@
         }),
 
         /// An array literal constructed from one repeated element: `[0u8; N]`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Repeat(ExprRepeat #full {
             pub attrs: Vec<Attribute>,
             pub bracket_token: token::Bracket,
@@ -399,6 +477,8 @@
         }),
 
         /// A parenthesized expression: `(a + b)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Paren(ExprParen #full {
             pub attrs: Vec<Attribute>,
             pub paren_token: token::Paren,
@@ -410,6 +490,8 @@
         /// This variant is important for faithfully representing the precedence
         /// of expressions and is related to `None`-delimited spans in a
         /// `TokenStream`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Group(ExprGroup #full {
             pub attrs: Vec<Attribute>,
             pub group_token: token::Group,
@@ -417,6 +499,8 @@
         }),
 
         /// A try-expression: `expr?`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Try(ExprTry #full {
             pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
@@ -424,6 +508,8 @@
         }),
 
         /// A catch expression: `do catch { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Catch(ExprCatch #full {
             pub attrs: Vec<Attribute>,
             pub do_token: Token![do],
@@ -432,6 +518,8 @@
         }),
 
         /// A yield expression: `yield expr`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Yield(ExprYield #full {
             pub attrs: Vec<Attribute>,
             pub yield_token: Token![yield],
@@ -439,6 +527,9 @@
         }),
 
         /// Tokens in expression position not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Verbatim(ExprVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -521,6 +612,9 @@
 ast_enum! {
     /// A struct or tuple struct field accessed in a struct literal or field
     /// expression.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum Member {
         /// A named field like `self.x`.
         Named(Ident),
@@ -531,6 +625,9 @@
 
 ast_struct! {
     /// The index of an unnamed tuple struct field.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Index #manual_extra_traits {
         pub index: u32,
         pub span: Span,
@@ -568,6 +665,8 @@
 ast_struct! {
     /// The `::<>` explicit type parameters passed to a method call:
     /// `parse::<u64>()`.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct MethodTurbofish {
         pub colon2_token: Token![::],
         pub lt_token: Token![<],
@@ -579,6 +678,8 @@
 #[cfg(feature = "full")]
 ast_enum! {
     /// An individual generic argument to a method, like `T`.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub enum GenericMethodArgument {
         /// A type argument.
         Type(Type),
@@ -593,6 +694,8 @@
 #[cfg(feature = "full")]
 ast_struct! {
     /// A field-value pair in a struct literal.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct FieldValue {
         /// Attributes tagged on the field.
         pub attrs: Vec<Attribute>,
@@ -612,6 +715,8 @@
 #[cfg(feature = "full")]
 ast_struct! {
     /// A lifetime labeling a `for`, `while`, or `loop`.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct Label {
         pub name: Lifetime,
         pub colon_token: Token![:],
@@ -621,6 +726,8 @@
 #[cfg(feature = "full")]
 ast_struct! {
     /// A braced block containing Rust statements.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct Block {
         pub brace_token: token::Brace,
         /// Statements in a block
@@ -631,6 +738,8 @@
 #[cfg(feature = "full")]
 ast_enum! {
     /// A statement, usually ending in a semicolon.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub enum Stmt {
         /// A local (let) binding.
         Local(Local),
@@ -649,6 +758,8 @@
 #[cfg(feature = "full")]
 ast_struct! {
     /// A local `let` binding: `let x: u64 = s.parse()?`.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct Local {
         pub attrs: Vec<Attribute>,
         pub let_token: Token![let],
@@ -664,6 +775,8 @@
     /// A pattern in a local binding, function signature, match expression, or
     /// various other places.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -674,11 +787,15 @@
     #[cfg_attr(feature = "cargo-clippy", allow(enum_variant_names))]
     pub enum Pat {
         /// A pattern that matches any value: `_`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Wild(PatWild {
             pub underscore_token: Token![_],
         }),
 
         /// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Ident(PatIdent {
             pub by_ref: Option<Token![ref]>,
             pub mutability: Option<Token![mut]>,
@@ -687,6 +804,8 @@
         }),
 
         /// A struct or struct variant pattern: `Variant { x, y, .. }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Struct(PatStruct {
             pub path: Path,
             pub brace_token: token::Brace,
@@ -695,6 +814,8 @@
         }),
 
         /// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub TupleStruct(PatTupleStruct {
             pub path: Path,
             pub pat: PatTuple,
@@ -707,12 +828,16 @@
         /// constants or associated constants. Quailfied path patterns like
         /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
         /// associated constants.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Path(PatPath {
             pub qself: Option<QSelf>,
             pub path: Path,
         }),
 
         /// A tuple pattern: `(a, b)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Tuple(PatTuple {
             pub paren_token: token::Paren,
             pub front: Punctuated<Pat, Token![,]>,
@@ -722,12 +847,16 @@
         }),
 
         /// A box pattern: `box v`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Box(PatBox {
             pub box_token: Token![box],
             pub pat: Box<Pat>,
         }),
 
         /// A reference pattern: `&mut (first, second)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Ref(PatRef {
             pub and_token: Token![&],
             pub mutability: Option<Token![mut]>,
@@ -738,11 +867,15 @@
         ///
         /// This holds an `Expr` rather than a `Lit` because negative numbers
         /// are represented as an `Expr::Unary`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Lit(PatLit {
             pub expr: Box<Expr>,
         }),
 
         /// A range pattern: `1..=2`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Range(PatRange {
             pub lo: Box<Expr>,
             pub limits: RangeLimits,
@@ -750,6 +883,8 @@
         }),
 
         /// A dynamically sized slice pattern: `[a, b, i.., y, z]`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Slice(PatSlice {
             pub bracket_token: token::Bracket,
             pub front: Punctuated<Pat, Token![,]>,
@@ -760,11 +895,15 @@
         }),
 
         /// A macro in expression position.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro(PatMacro {
             pub mac: Macro,
         }),
 
         /// Tokens in pattern position not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Verbatim(PatVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -810,6 +949,8 @@
     /// #   false
     /// # }
     /// ```
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct Arm {
         pub attrs: Vec<Attribute>,
         pub pats: Punctuated<Pat, Token![|]>,
@@ -823,6 +964,8 @@
 #[cfg(feature = "full")]
 ast_enum! {
     /// Limit types of a range, inclusive or exclusive.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     #[cfg_attr(feature = "clone-impls", derive(Copy))]
     pub enum RangeLimits {
         /// Inclusive at the beginning, exclusive at the end.
@@ -838,6 +981,8 @@
     ///
     /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` are treated
     /// the same as `x: x, y: ref y, z: ref mut z` but there is no colon token.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct FieldPat {
         pub attrs: Vec<Attribute>,
         pub member: Member,
diff --git a/src/file.rs b/src/file.rs
index 5875348..357cf6e 100644
--- a/src/file.rs
+++ b/src/file.rs
@@ -10,6 +10,8 @@
 
 ast_struct! {
     /// A complete file of Rust source code.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct File {
         pub shebang: Option<String>,
         pub attrs: Vec<Attribute>,
diff --git a/src/generics.rs b/src/generics.rs
index 0e20052..bb61e6c 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -12,6 +12,9 @@
 ast_struct! {
     /// Lifetimes and type parameters attached to a declaration of a function,
     /// enum, trait, etc.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     #[derive(Default)]
     pub struct Generics {
         pub lt_token: Option<Token![<]>,
@@ -25,6 +28,9 @@
     /// A generic type parameter, lifetime, or const generic: `T: Into<String>`,
     /// `'a: 'b`, `const LEN: usize`.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -32,6 +38,9 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum GenericParam {
         /// A generic type parameter: `T: Into<String>`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Type(TypeParam {
             pub attrs: Vec<Attribute>,
             pub ident: Ident,
@@ -42,6 +51,9 @@
         }),
 
         /// A lifetime definition: `'a: 'b + 'c + 'd`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Lifetime(LifetimeDef {
             pub attrs: Vec<Attribute>,
             pub lifetime: Lifetime,
@@ -50,6 +62,9 @@
         }),
 
         /// A const generic parameter: `const LENGTH: usize`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Const(ConstParam {
             pub attrs: Vec<Attribute>,
             pub const_token: Token![const],
@@ -62,22 +77,31 @@
     }
 }
 
+/// Returned by `Generics::split_for_impl`.
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature and the `"printing"` feature.*
 #[cfg(feature = "printing")]
 #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
-/// Returned by `Generics::split_for_impl`.
 pub struct ImplGenerics<'a>(&'a Generics);
 
+/// Returned by `Generics::split_for_impl`.
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature and the `"printing"` feature.*
 #[cfg(feature = "printing")]
 #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
-/// Returned by `Generics::split_for_impl`.
 pub struct TypeGenerics<'a>(&'a Generics);
 
+/// Returned by `TypeGenerics::as_turbofish`.
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature and the `"printing"` feature.*
 #[cfg(feature = "printing")]
 #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
-/// Returned by `TypeGenerics::as_turbofish`.
 pub struct Turbofish<'a>(&'a Generics);
 
 #[cfg(feature = "printing")]
@@ -101,6 +125,9 @@
     /// # ;
     /// # }
     /// ```
+    ///
+    /// *This method is available if Syn is built with the `"derive"` or
+    /// `"full"` feature and the `"printing"` feature.*
     pub fn split_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) {
         (
             ImplGenerics(self),
@@ -113,6 +140,9 @@
 #[cfg(feature = "printing")]
 impl<'a> TypeGenerics<'a> {
     /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.
+    ///
+    /// *This method is available if Syn is built with the `"derive"` or
+    /// `"full"` feature and the `"printing"` feature.*
     pub fn as_turbofish(&self) -> Turbofish {
         Turbofish(self.0)
     }
@@ -120,6 +150,9 @@
 
 ast_struct! {
     /// A set of bound lifetimes: `for<'a, 'b, 'c>`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     #[derive(Default)]
     pub struct BoundLifetimes {
         pub for_token: Token![for],
@@ -155,6 +188,9 @@
 
 ast_enum_of_structs! {
     /// A trait or lifetime used as a bound on a type parameter.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum TypeParamBound {
         pub Trait(TraitBound),
         pub Lifetime(Lifetime),
@@ -163,6 +199,9 @@
 
 ast_struct! {
     /// A trait used as a bound on a type parameter.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct TraitBound {
         pub modifier: TraitBoundModifier,
         /// The `for<'a>` in `for<'a> Foo<&'a T>`
@@ -175,6 +214,9 @@
 ast_enum! {
     /// A modifier on a trait bound, currently only used for the `?` in
     /// `?Sized`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     #[cfg_attr(feature = "clone-impls", derive(Copy))]
     pub enum TraitBoundModifier {
         None,
@@ -185,6 +227,9 @@
 ast_struct! {
     /// A `where` clause in a definition: `where T: Deserialize<'de>, D:
     /// 'static`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct WhereClause {
         pub where_token: Token![where],
         pub predicates: Punctuated<WherePredicate, Token![,]>,
@@ -194,6 +239,9 @@
 ast_enum_of_structs! {
     /// A single predicate in a `where` clause: `T: Deserialize<'de>`.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -201,6 +249,9 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum WherePredicate {
         /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Type(PredicateType {
             /// Any lifetimes from a `for` binding
             pub lifetimes: Option<BoundLifetimes>,
@@ -212,6 +263,9 @@
         }),
 
         /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Lifetime(PredicateLifetime {
             pub lifetime: Lifetime,
             pub colon_token: Option<Token![:]>,
@@ -219,6 +273,9 @@
         }),
 
         /// An equality predicate in a `where` clause (unsupported).
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Eq(PredicateEq {
             pub lhs_ty: Type,
             pub eq_token: Token![=],
diff --git a/src/item.rs b/src/item.rs
index 0bc57aa..4fef2b4 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -20,6 +20,8 @@
 ast_enum_of_structs! {
     /// Things that can appear directly inside of a module or scope.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -27,6 +29,8 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum Item {
         /// An `extern crate` item: `extern crate serde`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub ExternCrate(ItemExternCrate {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -38,6 +42,8 @@
         }),
 
         /// A use declaration: `use std::collections::HashMap`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Use(ItemUse {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -49,6 +55,8 @@
         }),
 
         /// A static item: `static BIKE: Shed = Shed(42)`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Static(ItemStatic {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -63,6 +71,8 @@
         }),
 
         /// A constant item: `const MAX: u16 = 65535`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Const(ItemConst {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -75,7 +85,10 @@
             pub semi_token: Token![;],
         }),
 
-        /// A free-standing function: `fn process(n: usize) -> Result<()> { ... }`.
+        /// A free-standing function: `fn process(n: usize) -> Result<()> { ...
+        /// }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Fn(ItemFn {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -88,6 +101,8 @@
         }),
 
         /// A module or module declaration: `mod m` or `mod m { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Mod(ItemMod {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -98,6 +113,8 @@
         }),
 
         /// A block of foreign items: `extern "C" { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub ForeignMod(ItemForeignMod {
             pub attrs: Vec<Attribute>,
             pub abi: Abi,
@@ -106,6 +123,8 @@
         }),
 
         /// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Type(ItemType {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -118,6 +137,8 @@
         }),
 
         /// A struct definition: `struct Foo<A> { x: A }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Struct(ItemStruct {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -129,6 +150,8 @@
         }),
 
         /// An enum definition: `enum Foo<A, B> { C<A>, D<B> }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Enum(ItemEnum {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -140,6 +163,8 @@
         }),
 
         /// A union definition: `union Foo<A, B> { x: A, y: B }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Union(ItemUnion {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -150,6 +175,8 @@
         }),
 
         /// A trait definition: `pub trait Iterator { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Trait(ItemTrait {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -166,6 +193,8 @@
 
         /// An impl block providing trait or associated items: `impl<A> Trait
         /// for Data<A> { ... }`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Impl(ItemImpl {
             pub attrs: Vec<Attribute>,
             pub defaultness: Option<Token![default]>,
@@ -181,6 +210,8 @@
         }),
 
         /// A macro invocation, which includes `macro_rules!` definitions.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro(ItemMacro {
             pub attrs: Vec<Attribute>,
             /// The `example` in `macro_rules! example { ... }`.
@@ -190,6 +221,8 @@
         }),
 
         /// A 2.0-style declarative macro introduced by the `macro` keyword.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro2(ItemMacro2 #manual_extra_traits {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -202,6 +235,8 @@
         }),
 
         /// Tokens forming an item not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Verbatim(ItemVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -295,6 +330,8 @@
 ast_enum_of_structs! {
     /// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -302,15 +339,23 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum UseTree {
         /// An identifier imported by a `use` item: `Type` or `Type as Renamed`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Path(UsePath {
             pub ident: Ident,
             pub rename: Option<(Token![as], Ident)>,
         }),
+
         /// A glob import in a `use` item: `*`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Glob(UseGlob {
             pub star_token: Token![*],
         }),
+
         /// A braced list of imports in a `use` item: `{A, B, C}`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub List(UseList {
             pub brace_token: token::Brace,
             pub items: Punctuated<UseTree, Token![,]>,
@@ -321,6 +366,8 @@
 ast_enum_of_structs! {
     /// An item within an `extern` block.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -328,6 +375,8 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum ForeignItem {
         /// A foreign function in an `extern` block.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Fn(ForeignItemFn {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -337,6 +386,8 @@
         }),
 
         /// A foreign static item in an `extern` block: `static ext: u8`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Static(ForeignItemStatic {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -349,6 +400,8 @@
         }),
 
         /// A foreign type in an `extern` block: `type void`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Type(ForeignItemType {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -358,6 +411,8 @@
         }),
 
         /// Tokens in an `extern` block not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Verbatim(ForeignItemVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -387,6 +442,8 @@
 ast_enum_of_structs! {
     /// An item declaration within the definition of a trait.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -394,6 +451,8 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum TraitItem {
         /// An associated constant within the definition of a trait.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Const(TraitItemConst {
             pub attrs: Vec<Attribute>,
             pub const_token: Token![const],
@@ -405,6 +464,8 @@
         }),
 
         /// A trait method within the definition of a trait.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Method(TraitItemMethod {
             pub attrs: Vec<Attribute>,
             pub sig: MethodSig,
@@ -413,6 +474,8 @@
         }),
 
         /// An associated type within the definition of a trait.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Type(TraitItemType {
             pub attrs: Vec<Attribute>,
             pub type_token: Token![type],
@@ -425,6 +488,8 @@
         }),
 
         /// A macro invocation within the definition of a trait.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro(TraitItemMacro {
             pub attrs: Vec<Attribute>,
             pub mac: Macro,
@@ -432,6 +497,8 @@
         }),
 
         /// Tokens within the definition of a trait not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Verbatim(TraitItemVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -461,6 +528,8 @@
 ast_enum_of_structs! {
     /// An item within an impl block.
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -468,6 +537,8 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum ImplItem {
         /// An associated constant within an impl block.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Const(ImplItemConst {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -482,6 +553,8 @@
         }),
 
         /// A method within an impl block.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Method(ImplItemMethod {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -491,6 +564,8 @@
         }),
 
         /// An associated type within an impl block.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Type(ImplItemType {
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
@@ -504,6 +579,8 @@
         }),
 
         /// A macro invocation within an impl block.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Macro(ImplItemMacro {
             pub attrs: Vec<Attribute>,
             pub mac: Macro,
@@ -511,6 +588,8 @@
         }),
 
         /// Tokens within an impl block not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Verbatim(ImplItemVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -540,6 +619,8 @@
 ast_struct! {
     /// A method's signature in a trait or implementation: `unsafe fn
     /// initialize(&self)`.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct MethodSig {
         pub constness: Option<Token![const]>,
         pub unsafety: Option<Token![unsafe]>,
@@ -551,6 +632,8 @@
 
 ast_struct! {
     /// Header of a function declaration, without including the body.
+    ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
     pub struct FnDecl {
         pub fn_token: Token![fn],
         pub generics: Generics,
@@ -566,6 +649,8 @@
     ///
     /// E.g. `bar: usize` as in `fn foo(bar: usize)`
     ///
+    /// *This type is available if Syn is built with the `"full"` feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -574,24 +659,33 @@
     pub enum FnArg {
         /// Self captured by reference in a function signature: `&self` or `&mut
         /// self`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub SelfRef(ArgSelfRef {
             pub and_token: Token![&],
             pub lifetime: Option<Lifetime>,
             pub mutability: Option<Token![mut]>,
             pub self_token: Token![self],
         }),
+
         /// Self captured by value in a function signature: `self` or `mut
         /// self`.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub SelfValue(ArgSelf {
             pub mutability: Option<Token![mut]>,
             pub self_token: Token![self],
         }),
+
         /// An explicitly typed pattern captured by a function signature.
+        ///
+        /// *This type is available if Syn is built with the `"full"` feature.*
         pub Captured(ArgCaptured {
             pub pat: Pat,
             pub colon_token: Token![:],
             pub ty: Type,
         }),
+
         /// A pattern whose type is inferred captured by a function signature.
         pub Inferred(Pat),
         /// A type not bound to any pattern in a function signature.
diff --git a/src/lib.rs b/src/lib.rs
index 948dd3e..7d236db 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -418,6 +418,8 @@
     ///     # fn visit_bin_op(&mut self, node: &'ast BinOp);
     /// }
     /// ```
+    ///
+    /// *This module is available if Syn is built with the `"visit"` feature.*
     #[cfg(feature = "visit")]
     pub mod visit;
 
@@ -453,6 +455,9 @@
     ///     # fn visit_bin_op_mut(&mut self, node: &mut BinOp);
     /// }
     /// ```
+    ///
+    /// *This module is available if Syn is built with the `"visit-mut"`
+    /// feature.*
     #[cfg(feature = "visit-mut")]
     pub mod visit_mut;
 
@@ -489,6 +494,8 @@
     ///     # fn fold_bin_op(&mut self, node: BinOp) -> BinOp;
     /// }
     /// ```
+    ///
+    /// *This module is available if Syn is built with the `"fold"` feature.*
     #[cfg(feature = "fold")]
     pub mod fold;
 
@@ -528,6 +535,8 @@
 ///
 /// [`syn::parse2`]: fn.parse2.html
 ///
+/// *This function is available if Syn is built with the `"parsing"` feature.*
+///
 /// # Examples
 ///
 /// ```rust
@@ -577,6 +586,8 @@
 ///
 /// [`Macro`]: struct.Macro.html
 /// [`syn::parse`]: fn.parse.html
+///
+/// *This function is available if Syn is built with the `"parsing"` feature.*
 #[cfg(feature = "parsing")]
 pub fn parse2<T>(tokens: proc_macro2::TokenStream) -> Result<T, ParseError>
 where
@@ -605,6 +616,8 @@
 
 /// Parse a string of Rust code into the chosen syntax tree node.
 ///
+/// *This function is available if Syn is built with the `"parsing"` feature.*
+///
 /// # Examples
 ///
 /// ```rust
@@ -643,6 +656,8 @@
 ///
 /// If present, either of these would be an error using `from_str`.
 ///
+/// *This function is available if Syn is built with the `"parsing"` feature.*
+///
 /// # Examples
 ///
 /// ```rust,no_run
@@ -725,6 +740,9 @@
 /// }
 /// ```
 ///
+/// *This macro is available if Syn is built with both the `"parsing"` and
+/// `"printing"` features.*
+///
 /// # Example
 ///
 /// The following helper function adds a bound `T: HeapSize` to every type
diff --git a/src/lifetime.rs b/src/lifetime.rs
index 4666da6..e192c5c 100644
--- a/src/lifetime.rs
+++ b/src/lifetime.rs
@@ -24,6 +24,9 @@
 ///   the XID_Start property.
 /// - All following characters must be Unicode code points with the XID_Continue
 ///   property.
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature.*
 #[cfg_attr(feature = "extra-traits", derive(Debug))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
 pub struct Lifetime {
diff --git a/src/lit.rs b/src/lit.rs
index 56a354d..24eb8e8 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -18,6 +18,9 @@
 ast_enum_of_structs! {
     /// A Rust literal such as a string or integer or boolean.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -25,24 +28,36 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum Lit {
         /// A UTF-8 string literal: `"foo"`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Str(LitStr #manual_extra_traits {
             token: Literal,
             pub span: Span,
         }),
 
         /// A byte string literal: `b"foo"`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub ByteStr(LitByteStr #manual_extra_traits {
             token: Literal,
             pub span: Span,
         }),
 
         /// A byte literal: `b'f'`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Byte(LitByte #manual_extra_traits {
             token: Literal,
             pub span: Span,
         }),
 
         /// A character literal: `'a'`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Char(LitChar #manual_extra_traits {
             token: Literal,
             pub span: Span,
@@ -52,6 +67,9 @@
         ///
         /// Holds up to 64 bits of data. Use `LitVerbatim` for any larger
         /// integer literal.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Int(LitInt #manual_extra_traits {
             token: Literal,
             pub span: Span,
@@ -60,12 +78,18 @@
         /// A floating point literal: `1f64` or `1.0e10f64`.
         ///
         /// Must be finite. May not be infinte or NaN.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Float(LitFloat #manual_extra_traits {
             token: Literal,
             pub span: Span,
         }),
 
         /// A boolean literal: `true` or `false`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Bool(LitBool #manual_extra_traits {
             pub value: bool,
             pub span: Span,
@@ -73,6 +97,9 @@
 
         /// A raw token literal not interpreted by Syn, possibly because it
         /// represents an integer larger than 64 bits.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Verbatim(LitVerbatim #manual_extra_traits {
             pub token: Literal,
             pub span: Span,
@@ -245,6 +272,9 @@
 ast_enum! {
     /// The style of a string literal, either plain quoted or a raw string like
     /// `r##"data"##`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum StrStyle #no_visit {
         /// An ordinary string like `"data"`.
         Cooked,
@@ -257,6 +287,9 @@
 
 ast_enum! {
     /// The suffix on an integer literal if any, like the `u8` in `127u8`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum IntSuffix #no_visit {
         I8,
         I16,
@@ -277,6 +310,9 @@
 ast_enum! {
     /// The suffix on a floating point literal if any, like the `f32` in
     /// `1.0f32`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum FloatSuffix #no_visit {
         F32,
         F64,
diff --git a/src/mac.rs b/src/mac.rs
index a5e123a..b17a466 100644
--- a/src/mac.rs
+++ b/src/mac.rs
@@ -17,6 +17,9 @@
 
 ast_struct! {
     /// A macro invocation: `println!("{}", mac)`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Macro #manual_extra_traits {
         pub path: Path,
         pub bang_token: Token![!],
@@ -27,6 +30,9 @@
 
 ast_enum! {
     /// A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum MacroDelimiter {
         Paren(Paren),
         Brace(Brace),
diff --git a/src/op.rs b/src/op.rs
index c0873a2..b9a8ef7 100644
--- a/src/op.rs
+++ b/src/op.rs
@@ -8,6 +8,9 @@
 
 ast_enum! {
     /// A binary operator: `+`, `+=`, `&`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     #[cfg_attr(feature = "clone-impls", derive(Copy))]
     pub enum BinOp {
         /// The `+` operator (addition)
@@ -71,6 +74,9 @@
 
 ast_enum! {
     /// A unary operator: `*`, `!`, `-`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     #[cfg_attr(feature = "clone-impls", derive(Copy))]
     pub enum UnOp {
         /// The `*` operator for dereferencing
diff --git a/src/parsers.rs b/src/parsers.rs
index fdbfdb9..e2af5f2 100644
--- a/src/parsers.rs
+++ b/src/parsers.rs
@@ -60,6 +60,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! named {
     ($name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
@@ -136,6 +138,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[cfg(not(synom_verbose_trace))]
 #[macro_export]
 macro_rules! call {
@@ -175,6 +179,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! map {
     ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
@@ -222,6 +228,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! not {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {
@@ -289,6 +297,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! cond {
     ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
@@ -363,6 +373,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! cond_reduce {
     ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
@@ -424,6 +436,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! many0 {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {{
@@ -564,6 +578,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! switch {
     ($i:expr, $submac:ident!( $($args:tt)* ), $($p:pat => $subrule:ident!( $($args2:tt)* ))|* ) => {
@@ -656,6 +672,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! value {
     ($i:expr, $res:expr) => {
@@ -687,6 +705,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! reject {
     ($i:expr,) => {{
@@ -710,6 +730,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! tuple {
     ($i:expr, $($rest:tt)*) => {
@@ -830,6 +852,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! alt {
     ($i:expr, $e:ident | $($rest:tt)*) => {
@@ -922,6 +946,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! do_parse {
     ($i:expr, ( $($rest:expr),* )) => {
@@ -1023,6 +1049,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! input_end {
     ($i:expr,) => {
@@ -1081,6 +1109,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! option {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {
@@ -1132,6 +1162,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! epsilon {
     ($i:expr,) => {
@@ -1210,6 +1242,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! syn {
     ($i:expr, $t:ty) => {
@@ -1240,6 +1274,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! parens {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {
@@ -1274,6 +1310,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! brackets {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {
@@ -1308,6 +1346,8 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[macro_export]
 macro_rules! braces {
     ($i:expr, $submac:ident!( $($args:tt)* )) => {
diff --git a/src/path.rs b/src/path.rs
index 27091b2..b6c7f6d 100644
--- a/src/path.rs
+++ b/src/path.rs
@@ -11,6 +11,9 @@
 
 ast_struct! {
     /// A path at which a named item is exported: `std::collections::HashMap`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Path {
         pub leading_colon: Option<Token![::]>,
         pub segments: Punctuated<PathSegment, Token![::]>,
@@ -45,6 +48,9 @@
 /// #
 /// # fn main() {}
 /// ```
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature and the `"printing"` feature.*
 #[cfg(feature = "printing")]
 #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
@@ -66,6 +72,9 @@
 
 ast_struct! {
     /// A segment of a path together with any path arguments on that segment.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct PathSegment {
         pub ident: Ident,
         pub arguments: PathArguments,
@@ -88,6 +97,9 @@
     /// Bracketed or parenthesized arguments of a path segment.
     ///
     /// E.g. `<K, V>` as in `HashMap<K, V>` or `(A, B) -> C` as in `Fn(A, B) -> C`
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum PathArguments {
         None,
         /// The `<'a, T>` in `std::slice::iter<'a, T>`.
@@ -115,6 +127,9 @@
 
 ast_enum! {
     /// An individual generic argument, like `'a`, `T`, or `Item = T`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum GenericArgument {
         /// A lifetime argument.
         Lifetime(Lifetime),
@@ -135,6 +150,9 @@
 ast_struct! {
     /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,
     /// V>`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct AngleBracketedGenericArguments {
         pub colon2_token: Option<Token![::]>,
         pub lt_token: Token![<],
@@ -145,6 +163,9 @@
 
 ast_struct! {
     /// A binding (equality constraint) on an associated type: `Item = u8`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Binding {
         pub ident: Ident,
         pub eq_token: Token![=],
@@ -155,6 +176,9 @@
 ast_struct! {
     /// Arguments of a function path segment: the `(A, B)` and `C` in `Fn(A,B)
     /// -> C`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct ParenthesizedGenericArguments {
         pub paren_token: token::Paren,
         /// `(A, B)`
@@ -181,6 +205,9 @@
     ///  ^~~~~~   ^
     ///  ty       position = 0
     /// ```
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct QSelf {
         pub lt_token: Token![<],
         pub ty: Box<Type>,
diff --git a/src/spanned.rs b/src/spanned.rs
index 2da45d7..c844fc7 100644
--- a/src/spanned.rs
+++ b/src/spanned.rs
@@ -9,6 +9,9 @@
 //! A trait that can provide the `Span` of the complete contents of a syntax
 //! tree node.
 //!
+//! *This module is available if Syn is built with both the `"parsing"` and
+//! `"printing"` features.*
+//!
 //! # Example
 //!
 //! Suppose in a procedural macro we have a [`Type`] that we want to assert
@@ -97,6 +100,9 @@
 /// See the [module documentation] for an example.
 ///
 /// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with both the `"parsing"` and
+/// `"printing"` features.*
 pub trait Spanned {
     /// Returns a `Span` covering the complete contents of this syntax tree
     /// node, or [`Span::call_site()`] if this node is empty.
diff --git a/src/synom.rs b/src/synom.rs
index 9f63d96..d14c3f8 100644
--- a/src/synom.rs
+++ b/src/synom.rs
@@ -41,6 +41,8 @@
 //! - [`syn!`](../macro.syn.html)
 //! - [`tuple!`](../macro.tuple.html)
 //! - [`value!`](../macro.value.html)
+//!
+//! *This module is available if Syn is built with the `"parsing"` feature.*
 
 use proc_macro2::TokenStream;
 
@@ -54,6 +56,8 @@
 /// Refer to the [module documentation] for details about parsing in Syn.
 ///
 /// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `"parsing"` feature.*
 pub trait Synom: Sized {
     fn parse(input: Cursor) -> PResult<Self>;
 
diff --git a/src/token.rs b/src/token.rs
index 8609fbb..d47bfa6 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -480,6 +480,8 @@
 /// See the [token module] documentation for details and examples.
 ///
 /// [token module]: token/index.html
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[cfg(feature = "parsing")]
 #[macro_export]
 macro_rules! punct {
@@ -535,6 +537,8 @@
 /// See the [token module] documentation for details and examples.
 ///
 /// [token module]: token/index.html
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
 #[cfg(feature = "parsing")]
 #[macro_export]
 macro_rules! keyword {
diff --git a/src/ty.rs b/src/ty.rs
index 39bae38..1f50969 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -17,6 +17,9 @@
 ast_enum_of_structs! {
     /// The possible types that a Rust value could have.
     ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
+    ///
     /// # Syntax tree enum
     ///
     /// This type is a [syntax tree enum].
@@ -24,12 +27,18 @@
     /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
     pub enum Type {
         /// A dynamically sized slice type: `[T]`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Slice(TypeSlice {
             pub bracket_token: token::Bracket,
             pub elem: Box<Type>,
         }),
 
         /// A fixed size array type: `[T; n]`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Array(TypeArray {
             pub bracket_token: token::Bracket,
             pub elem: Box<Type>,
@@ -38,6 +47,9 @@
         }),
 
         /// A raw pointer type: `*const T` or `*mut T`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Ptr(TypePtr {
             pub star_token: Token![*],
             pub const_token: Option<Token![const]>,
@@ -46,6 +58,9 @@
         }),
 
         /// A reference type: `&'a T` or `&'a mut T`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Reference(TypeReference {
             pub and_token: Token![&],
             pub lifetime: Option<Lifetime>,
@@ -54,6 +69,9 @@
         }),
 
         /// A bare function type: `fn(usize) -> bool`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub BareFn(TypeBareFn {
             pub unsafety: Option<Token![unsafe]>,
             pub abi: Option<Abi>,
@@ -66,11 +84,17 @@
         }),
 
         /// The never type: `!`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Never(TypeNever {
             pub bang_token: Token![!],
         }),
 
         /// A tuple type: `(A, B, C, String)`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Tuple(TypeTuple {
             pub paren_token: token::Paren,
             pub elems: Punctuated<Type, Token![,]>,
@@ -80,6 +104,9 @@
         /// self-type as in `<Vec<T> as SomeTrait>::Associated`.
         ///
         /// Type arguments are stored in the Path itself.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Path(TypePath {
             pub qself: Option<QSelf>,
             pub path: Path,
@@ -87,6 +114,9 @@
 
         /// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a
         /// trait or a lifetime.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub TraitObject(TypeTraitObject {
             pub dyn_token: Option<Token![dyn]>,
             pub bounds: Punctuated<TypeParamBound, Token![+]>,
@@ -94,34 +124,52 @@
 
         /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
         /// a lifetime.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub ImplTrait(TypeImplTrait {
             pub impl_token: Token![impl],
             pub bounds: Punctuated<TypeParamBound, Token![+]>,
         }),
 
         /// A parenthesized type equivalent to the inner type.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Paren(TypeParen {
             pub paren_token: token::Paren,
             pub elem: Box<Type>,
         }),
 
         /// A type contained within invisible delimiters.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Group(TypeGroup {
             pub group_token: token::Group,
             pub elem: Box<Type>,
         }),
 
         /// Indication that a type should be inferred by the compiler: `_`.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Infer(TypeInfer {
             pub underscore_token: Token![_],
         }),
 
         /// A macro in the type position.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Macro(TypeMacro {
             pub mac: Macro,
         }),
 
         /// Tokens in type position not interpreted by Syn.
+        ///
+        /// *This type is available if Syn is built with the `"derive"` or
+        /// `"full"` feature.*
         pub Verbatim(TypeVerbatim #manual_extra_traits {
             pub tts: TokenStream,
         }),
@@ -150,6 +198,9 @@
 
 ast_struct! {
     /// The binary interface of a function: `extern "C"`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct Abi {
         pub extern_token: Token![extern],
         pub name: Option<LitStr>,
@@ -158,6 +209,9 @@
 
 ast_struct! {
     /// An argument in a function type: the `usize` in `fn(usize) -> bool`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub struct BareFnArg {
         pub name: Option<(BareFnArgName, Token![:])>,
         pub ty: Type,
@@ -166,6 +220,9 @@
 
 ast_enum! {
     /// Name of an argument in a function type: the `n` in `fn(n: usize)`.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum BareFnArgName {
         /// Argument given a name.
         Named(Ident),
@@ -176,6 +233,9 @@
 
 ast_enum! {
     /// Return type of a function signature.
+    ///
+    /// *This type is available if Syn is built with the `"derive"` or `"full"`
+    /// feature.*
     pub enum ReturnType {
         /// Return type is not specified.
         ///