diff --git a/src/expr.rs b/src/expr.rs
index 523efd8..97db379 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -552,11 +552,17 @@
     ///
     /// E.g. `0..=10 => { println!("match!") }` as in
     ///
-    /// ```rust,ignore
+    /// ```rust
+    /// # #![feature(dotdoteq_in_patterns)]
+    /// #
+    /// # fn main() {
+    /// #     let n = 0;
     /// match n {
-    ///     0..=10 => { println!("match!") },
+    ///     0..=10 => { println!("match!") }
     ///     // ..
+    ///     # _ => {}
     /// }
+    /// # }
     /// ```
     pub struct Arm {
         pub attrs: Vec<Attribute>,
@@ -658,28 +664,28 @@
     #[cfg(feature = "full")]
     use synom::parse_error;
 
-    /// When we're parsing expressions which occur before blocks, like in
-    /// an if statement's condition, we cannot parse a struct literal.
-    ///
-    /// Struct literals are ambiguous in certain positions
-    /// https://github.com/rust-lang/rfcs/pull/92
+    // When we're parsing expressions which occur before blocks, like in an if
+    // statement's condition, we cannot parse a struct literal.
+    //
+    // Struct literals are ambiguous in certain positions
+    // https://github.com/rust-lang/rfcs/pull/92
     macro_rules! ambiguous_expr {
         ($i:expr, $allow_struct:ident) => {
             ambiguous_expr($i, $allow_struct, true)
         };
     }
 
-    /// When we are parsing an optional suffix expression, we cannot allow
-    /// blocks if structs are not allowed.
-    ///
-    /// Example:
-    /// ```ignore
-    /// if break { } { }
-    /// // is ambiguous between:
-    /// if (break { }) { }
-    /// // - or -
-    /// if (break) { } { }
-    /// ```
+    // When we are parsing an optional suffix expression, we cannot allow blocks
+    // if structs are not allowed.
+    //
+    // Example:
+    //
+    //     if break {} {}
+    //
+    // is ambiguous between:
+    //
+    //     if (break {}) {}
+    //     if (break) {} {}
     #[cfg(feature = "full")]
     macro_rules! opt_ambiguous_expr {
         ($i:expr, $allow_struct:ident) => {
@@ -698,7 +704,7 @@
     #[cfg(feature = "full")]
     named!(expr_no_struct -> Expr, ambiguous_expr!(false));
 
-    /// Parse an arbitrary expression.
+    // Parse an arbitrary expression.
     #[cfg(feature = "full")]
     fn ambiguous_expr(i: Cursor,
                       allow_struct: bool,
@@ -725,7 +731,7 @@
         )
     }
 
-    /// Parse a left-associative binary operator.
+    // Parse a left-associative binary operator.
     macro_rules! binop {
         (
             $name: ident,
@@ -750,21 +756,19 @@
         }
     }
 
-    /// ```ignore
-    /// <placement> = <placement> ..
-    /// <placement> += <placement> ..
-    /// <placement> -= <placement> ..
-    /// <placement> *= <placement> ..
-    /// <placement> /= <placement> ..
-    /// <placement> %= <placement> ..
-    /// <placement> ^= <placement> ..
-    /// <placement> &= <placement> ..
-    /// <placement> |= <placement> ..
-    /// <placement> <<= <placement> ..
-    /// <placement> >>= <placement> ..
-    /// ```
-    ///
-    /// NOTE: This operator is right-associative.
+    // <placement> = <placement> ..
+    // <placement> += <placement> ..
+    // <placement> -= <placement> ..
+    // <placement> *= <placement> ..
+    // <placement> /= <placement> ..
+    // <placement> %= <placement> ..
+    // <placement> ^= <placement> ..
+    // <placement> &= <placement> ..
+    // <placement> |= <placement> ..
+    // <placement> <<= <placement> ..
+    // <placement> >>= <placement> ..
+    //
+    // NOTE: This operator is right-associative.
     #[cfg(feature = "full")]
     named!(assign_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
         mut e: call!(placement_expr, allow_struct, allow_block) >>
@@ -800,14 +804,12 @@
         (e)
     ));
 
-    /// ```ignore
-    /// <range> <- <range> ..
-    /// ```
-    ///
-    /// NOTE: The `in place { expr }` version of this syntax is parsed in
-    /// `atom_expr`, not here.
-    ///
-    /// NOTE: This operator is right-associative.
+    // <range> <- <range> ..
+    //
+    // NOTE: The `in place { expr }` version of this syntax is parsed in
+    // `atom_expr`, not here.
+    //
+    // NOTE: This operator is right-associative.
     #[cfg(feature = "full")]
     named!(placement_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
         mut e: call!(range_expr, allow_struct, allow_block) >>
@@ -831,19 +833,17 @@
         (e)
     ));
 
-    /// ```ignore
-    /// <or> ... <or> ..
-    /// <or> .. <or> ..
-    /// <or> ..
-    /// ```
-    ///
-    /// NOTE: This is currently parsed oddly - I'm not sure of what the exact
-    /// rules are for parsing these expressions are, but this is not correct.
-    /// For example, `a .. b .. c` is not a legal expression. It should not
-    /// be parsed as either `(a .. b) .. c` or `a .. (b .. c)` apparently.
-    ///
-    /// NOTE: The form of ranges which don't include a preceding expression are
-    /// parsed by `atom_expr`, rather than by this function.
+    // <or> ... <or> ..
+    // <or> .. <or> ..
+    // <or> ..
+    //
+    // NOTE: This is currently parsed oddly - I'm not sure of what the exact
+    // rules are for parsing these expressions are, but this is not correct.
+    // For example, `a .. b .. c` is not a legal expression. It should not
+    // be parsed as either `(a .. b) .. c` or `a .. (b .. c)` apparently.
+    //
+    // NOTE: The form of ranges which don't include a preceding expression are
+    // parsed by `atom_expr`, rather than by this function.
     #[cfg(feature = "full")]
     named!(range_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
         mut e: call!(or_expr, allow_struct, allow_block) >>
@@ -863,27 +863,21 @@
         (e)
     ));
 
-    /// ```ignore
-    /// <and> || <and> ...
-    /// ```
+    // <and> || <and> ...
     binop!(or_expr, and_expr, map!(punct!(||), BinOp::Or));
 
-    /// ```ignore
-    /// <compare> && <compare> ...
-    /// ```
+    // <compare> && <compare> ...
     binop!(and_expr, compare_expr, map!(punct!(&&), BinOp::And));
 
-    /// ```ignore
-    /// <bitor> == <bitor> ...
-    /// <bitor> != <bitor> ...
-    /// <bitor> >= <bitor> ...
-    /// <bitor> <= <bitor> ...
-    /// <bitor> > <bitor> ...
-    /// <bitor> < <bitor> ...
-    /// ```
-    ///
-    /// NOTE: This operator appears to be parsed as left-associative, but errors
-    /// if it is used in a non-associative manner.
+    // <bitor> == <bitor> ...
+    // <bitor> != <bitor> ...
+    // <bitor> >= <bitor> ...
+    // <bitor> <= <bitor> ...
+    // <bitor> > <bitor> ...
+    // <bitor> < <bitor> ...
+    //
+    // NOTE: This operator appears to be parsed as left-associative, but errors
+    // if it is used in a non-associative manner.
     binop!(compare_expr, bitor_expr, alt!(
         punct!(==) => { BinOp::Eq }
         |
@@ -905,9 +899,7 @@
         punct!(>) => { BinOp::Gt }
     ));
 
-    /// ```ignore
-    /// <bitxor> | <bitxor> ...
-    /// ```
+    // <bitxor> | <bitxor> ...
     binop!(bitor_expr, bitxor_expr, do_parse!(
         not!(punct!(||)) >>
         not!(punct!(|=)) >>
@@ -915,9 +907,7 @@
         (BinOp::BitOr(t))
     ));
 
-    /// ```ignore
-    /// <bitand> ^ <bitand> ...
-    /// ```
+    // <bitand> ^ <bitand> ...
     binop!(bitxor_expr, bitand_expr, do_parse!(
         // NOTE: Make sure we aren't looking at ^=.
         not!(punct!(^=)) >>
@@ -925,9 +915,7 @@
         (BinOp::BitXor(t))
     ));
 
-    /// ```ignore
-    /// <shift> & <shift> ...
-    /// ```
+    // <shift> & <shift> ...
     binop!(bitand_expr, shift_expr, do_parse!(
         // NOTE: Make sure we aren't looking at && or &=.
         not!(punct!(&&)) >>
@@ -936,31 +924,25 @@
         (BinOp::BitAnd(t))
     ));
 
-    /// ```ignore
-    /// <arith> << <arith> ...
-    /// <arith> >> <arith> ...
-    /// ```
+    // <arith> << <arith> ...
+    // <arith> >> <arith> ...
     binop!(shift_expr, arith_expr, alt!(
         punct!(<<) => { BinOp::Shl }
         |
         punct!(>>) => { BinOp::Shr }
     ));
 
-    /// ```ignore
-    /// <term> + <term> ...
-    /// <term> - <term> ...
-    /// ```
+    // <term> + <term> ...
+    // <term> - <term> ...
     binop!(arith_expr, term_expr, alt!(
         punct!(+) => { BinOp::Add }
         |
         punct!(-) => { BinOp::Sub }
     ));
 
-    /// ```ignore
-    /// <cast> * <cast> ...
-    /// <cast> / <cast> ...
-    /// <cast> % <cast> ...
-    /// ```
+    // <cast> * <cast> ...
+    // <cast> / <cast> ...
+    // <cast> % <cast> ...
     binop!(term_expr, cast_expr, alt!(
         punct!(*) => { BinOp::Mul }
         |
@@ -969,10 +951,8 @@
         punct!(%) => { BinOp::Rem }
     ));
 
-    /// ```ignore
-    /// <unary> as <ty>
-    /// <unary> : <ty>
-    /// ```
+    // <unary> as <ty>
+    // <unary> : <ty>
     named!(cast_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
         mut e: call!(unary_expr, allow_struct, allow_block) >>
         many0!(alt!(
@@ -1007,12 +987,10 @@
         (e)
     ));
 
-    /// ```
-    /// <UnOp> <trailer>
-    /// & <trailer>
-    /// &mut <trailer>
-    /// box <trailer>
-    /// ```
+    // <UnOp> <trailer>
+    // & <trailer>
+    // &mut <trailer>
+    // box <trailer>
     #[cfg(feature = "full")]
     named!(unary_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!(
         do_parse!(
@@ -1062,14 +1040,12 @@
         call!(trailer_expr, allow_struct, allow_block)
     ));
 
-    /// ```ignore
-    /// <atom> (..<args>) ...
-    /// <atom> . <ident> (..<args>) ...
-    /// <atom> . <ident> ...
-    /// <atom> . <lit> ...
-    /// <atom> [ <expr> ] ...
-    /// <atom> ? ...
-    /// ```
+    // <atom> (..<args>) ...
+    // <atom> . <ident> (..<args>) ...
+    // <atom> . <ident> ...
+    // <atom> . <lit> ...
+    // <atom> [ <expr> ] ...
+    // <atom> ? ...
     #[cfg(feature = "full")]
     named!(trailer_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
         mut e: call!(atom_expr, allow_struct, allow_block) >>
@@ -1152,8 +1128,8 @@
         (e)
     ));
 
-    /// Parse all atomic expressions which don't have to worry about precidence
-    /// interactions, as they are fully contained.
+    // Parse all atomic expressions which don't have to worry about precidence
+    // interactions, as they are fully contained.
     #[cfg(feature = "full")]
     named!(atom_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!(
         syn!(ExprGroup) => { ExprKind::Group } // must be placed first
@@ -1659,7 +1635,7 @@
         // position where structs are not allowed, such as in if statement
         // conditions. For example:
         //
-        // if return { println!("A") } { } // Prints "A"
+        // if return { println!("A") } {} // Prints "A"
         ret_value: option!(ambiguous_expr!(allow_struct)) >>
         (ExprRet {
             expr: ret_value.map(Box::new),
@@ -2281,8 +2257,8 @@
     use attr::FilterAttrs;
     use quote::{Tokens, ToTokens};
 
-    /// If the given expression is a bare `ExprStruct`, wraps it in parenthesis
-    /// before appending it to `Tokens`.
+    // If the given expression is a bare `ExprStruct`, wraps it in parenthesis
+    // before appending it to `Tokens`.
     #[cfg(feature = "full")]
     fn wrap_bare_struct(tokens: &mut Tokens, e: &Expr) {
         if let ExprKind::Struct(_) = e.node {
diff --git a/src/lib.rs b/src/lib.rs
index 40472c5..bcad33a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -126,7 +126,7 @@
 ///
 /// # Examples
 ///
-/// ```rust,ignore
+/// ```rust
 /// extern crate proc_macro;
 /// use proc_macro::TokenStream;
 ///
@@ -137,7 +137,9 @@
 ///
 /// use syn::DeriveInput;
 ///
+/// # const IGNORE_TOKENS: &str = stringify! {
 /// #[proc_macro_derive(MyMacro)]
+/// # };
 /// pub fn my_macro(input: TokenStream) -> TokenStream {
 ///     // Parse the tokens into a syntax tree
 ///     let ast: DeriveInput = syn::parse(input).unwrap();
@@ -147,9 +149,11 @@
 ///         /* ... */
 ///     };
 ///
-///     // Parse back to a token stream and return it
-///     expanded.parse().unwrap()
+///     // Convert into a token stream and return it
+///     expanded.into()
 /// }
+/// #
+/// # fn main() {}
 /// ```
 #[cfg(feature = "parsing")]
 pub fn parse<T>(tokens: proc_macro::TokenStream) -> Result<T, ParseError>
diff --git a/src/ty.rs b/src/ty.rs
index b55f2f0..04339fe 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -256,13 +256,13 @@
     /// separately. `position` represents the index of the associated
     /// item qualified with this Self type.
     ///
-    /// ```rust,ignore
+    /// ```text
     /// <Vec<T> as a::b::Trait>::AssociatedItem
-    ///  ^~~~~     ~~~~~~~~~~~~~~^
+    ///  ^~~~~~    ~~~~~~~~~~~~~~^
     ///  ty        position = 3
     ///
     /// <Vec<T>>::AssociatedItem
-    ///  ^~~~~    ^
+    ///  ^~~~~~   ^
     ///  ty       position = 0
     /// ```
     pub struct QSelf {